Reflex and the Limits of Continuous Learning in Large Language Models.
Craig Brown
CISOware, Boston, MA.
Abstract
Modern large language models (LLMs) such as GPT‑4, LLaMA‑70B, and Mixtral‑8x7B achieve unprecedented fluency in human language. Yet despite their power, they remain frozen snapshots of knowledge, unable to continuously learn from new data as humans do. This paper demonstrates why continuous model updating is infeasible given current computational and economic constraints. It argues that retrieval‑augmented architectures, exemplified by the Reflex bridge, are the only viable method for real‑time integration of new knowledge. Unlike retraining‑based approaches, the Reflex bridge separates reasoning from knowledge storage, enabling immediate adaptation to new incidents without requiring full model retraining.
1. Introduction.
Artificial intelligence has entered a transformative era, with large language models now underpinning applications in research, government, and industry. These models, built on transformer architectures with billions to trillions of parameters, have demonstrated remarkable capabilities in natural language understanding, generation, and reasoning tasks. Through self-attention mechanisms and extensive pre-training on diverse text corpora, LLMs learn complex patterns and representations that enable them to perform zero-shot and few-shot learning across numerous domains. However, their utility is constrained by a fundamental limitation: once trained, an LLM cannot readily incorporate new knowledge. The model’s weights, which encode learned patterns through gradient descent optimization during training, become static after the training process concludes.
Unlike human cognition, which integrates new experiences incrementally through neuroplasticity and memory consolidation processes, an LLM’s parameters remain fixed until retraining. This creates a temporal knowledge cutoff, rendering the model unable to access or reason about events, facts, or developments that occurred after its training data collection period.
The question driving this paper is: Can a domain-specific model (e.g., for information security) continuously learn in real time? We demonstrate that the answer is no — not with today’s technology. The computational requirements for continuous learning present insurmountable challenges: fine-tuning requires processing through billions of parameters with associated memory and compute costs, while full retraining demands weeks to months of GPU time on specialized hardware clusters. Even parameter-efficient fine-tuning methods like LoRA (Low-Rank Adaptation) or prompt tuning, while reducing computational overhead, still require batch processing and cannot achieve true real-time updates. Furthermore, catastrophic forgetting — where neural networks lose previously learned information when trained on new data — poses a significant obstacle to incremental learning approaches. Instead, systems must rely on retrieval-augmented methods.
These architectures decouple the model’s parametric knowledge (encoded in weights) from non-parametric knowledge (stored in external databases or indices), allowing for dynamic information retrieval at inference time without modifying the underlying model. Reflex, an architecture designed for cybersecurity incident response, and integrating its data into a model in real time illustrates why this approach is not merely preferable but unavoidable.
2. The Training-Inference Divide.
LLMs are trained on trillions of tokens and billions of parameters. The pre-training process involves self-supervised learning objectives, primarily next-token prediction (autoregressive modeling) or masked language modeling, where models learn to predict missing or subsequent tokens in vast text sequences. This training leverages massive datasets compiled from web crawls, books, academic papers, and curated text sources, often totaling multiple terabytes of raw text. The transformer architecture’s self-attention mechanism computes relationships between all token pairs in a sequence, requiring quadratic computational complexity with respect to sequence length. Training requires thousands of GPUs or TPUs, often organized in distributed computing clusters using techniques like data parallelism, model parallelism, and pipeline parallelism to handle the computational load.
Memory requirements scale with model size, batch size, and sequence length, necessitating high-bandwidth interconnects between processing units. The training process involves weeks of runtime, during which billions of gradient updates are computed through backpropagation, with careful hyperparameter tuning for learning rates, warmup schedules, and regularization techniques. Infrastructure costs include not only hardware but also electricity consumption, cooling systems, and engineering overhead, resulting in costs in the tens of millions of dollars. The outcome is a fixed parameter set — the model “weights.” These weights encode the model’s learned representations in matrices distributed across embedding layers, attention heads, feed-forward networks, and normalization layers. Once produced, these weights are immutable unless the model undergoes another training cycle.
At inference time, models apply their learned patterns to new inputs. The forward pass through the network transforms input tokens through successive layers of attention and feed-forward operations, with each layer’s computations dependent only on the fixed weights and the current input. Models use techniques like beam search, nucleus sampling, or temperature-based sampling to generate output token distributions. They generate fluent and often accurate responses, but they do not update themselves. The inference process is fundamentally stateless beyond the current context — no gradients are computed, no weights are modified, and no learning occurs.
Each query is answered as though the model has never seen the input before, because it has no persistent memory beyond its context window. The context window, typically ranging from 2,000 to 128,000 tokens in current models, represents the only form of temporary “memory” available during inference, implemented through positional encodings and attention mechanisms that allow the model to reference earlier tokens in the current sequence. Once the context window is cleared or the conversation ends, all information from that interaction is lost to the model.
3. The Impossibility of Continuous Retraining.
Compute Constraints: A 70B-parameter model in half-precision (FP16/BF16) requires ~140 GB of memory for parameters alone, as each parameter occupies 2 bytes. However, training demands substantially more memory than just parameter storage. Gradient computation requires storing activations from the forward pass for backpropagation, optimizer states (such as momentum and variance estimates in Adam), and gradient values themselves, typically multiplying memory requirements by 12-20x. This means a 70B model can require 1.5-2.8 TB of memory during training. Each training step involves billions of GPU operations per batch, specifically floating-point operations (FLOPs) for matrix multiplications in attention mechanisms and feed-forward layers.
The computational cost scales as O(n²d) for attention operations, where n is sequence length and d is model dimension. Modern training requires specialized hardware like NVIDIA A100 or H100 GPUs with 40-80GB of high-bandwidth memory (HBM), necessitating model sharding across multiple devices. Gradient synchronization between devices introduces communication overhead, requiring high-speed interconnects like NVLink or InfiniBand. Continuous retraining on streaming data would require maintaining this infrastructure perpetually active, with associated costs for power (often 400W+ per GPU), cooling, and maintenance. The carbon footprint and operational expenses make this infeasible for any organization outside the largest technology companies.
Latency of Updates: Even with unlimited funding, retraining cycles last weeks. A full pre-training run requires processing the entire dataset through multiple epochs, with each epoch potentially taking days depending on dataset size and model complexity. Convergence typically requires seeing each training example multiple times, with learning rate schedules carefully tuned over thousands to millions of steps. Validation and hyperparameter tuning add additional overhead. Fine-tuning, while faster than pre-training, still requires hours to days for meaningful updates, depending on task complexity and dataset size.
Continual learning approaches face the challenge of catastrophic forgetting, requiring careful replay mechanisms or regularization techniques that further slow training. By completion, new data collected during that period is already outdated, creating a perpetual lag between world events and model knowledge.
Distribution Burden: Delivering an updated model is nontrivial: the binary may exceed 100 GB for large models, with 70B parameters in FP16 requiring 140 GB minimum, plus additional overhead for model architecture definitions, tokenizer files, and configuration data. Model quantization to INT8 or INT4 can reduce size but requires additional processing and may impact performance. Network bandwidth limitations mean transferring such files takes hours even on high-speed connections. Edge deployment scenarios face even greater challenges, with limited bandwidth and storage capacity. Version control becomes complex when managing frequent updates across distributed systems.
Regular redistribution at national or enterprise scale requires content delivery networks (CDNs), synchronization protocols, and rollback mechanisms. Organizations must coordinate updates across potentially thousands of deployment endpoints, manage compatibility between model versions, and ensure zero-downtime transitions. The logistical complexity of maintaining model consistency across a large deployment while managing storage, bandwidth, and computational resources is logistically impractical.
4. Why Humans Learn but LLMs Cannot.
Human cognition is plastic: neurons reorganize in real time as new experiences occur. The brain contains approximately 86 billion neurons with trillions of synaptic connections that undergo constant modification through mechanisms like long-term potentiation (LTP) and long-term depression (LTD). Synaptic plasticity allows connection strengths to change based on activity patterns, following Hebbian learning principles where “neurons that fire together wire together.” Structural plasticity enables the formation of new synaptic connections and pruning of unused ones throughout life. Neurogenesis in regions like the hippocampus creates new neurons even in adulthood. Multiple memory systems work in parallel: working memory for immediate processing, episodic memory for specific experiences, semantic memory for facts and concepts, and procedural memory for skills.
The hippocampus rapidly encodes new experiences that are gradually consolidated into cortical networks through sleep and replay mechanisms. Learning is incremental, adaptive, and continuous, with the brain seamlessly integrating new information while preserving existing knowledge through complementary learning systems.
In contrast, LLMs are rigid: their billions of parameters cannot be altered incrementally without destabilizing the network. Neural networks suffer from catastrophic forgetting — when trained on new data, they overwrite previously learned patterns unless careful measures are taken. The loss landscape of large models is highly non-convex with numerous local minima, making it difficult to update parameters for new information without disrupting existing knowledge. Each parameter in an LLM participates in representing multiple concepts through distributed representations, meaning changes to accommodate new information can have unpredictable effects across the model’s capabilities. The statistical maps they create during training are frozen.
These maps encode probability distributions over token sequences learned from the training corpus, with attention patterns and feature representations fixed in the model weights. The transformer architecture lacks mechanisms for selective, localized updates analogous to biological synaptic plasticity. Without separate memory systems or consolidation processes, LLMs cannot distinguish between information to preserve versus information to update. Gradient-based learning requires batched data and multiple passes to achieve stable updates, incompatible with single-example online learning. This is why an LLM cannot simply “read the newspaper” and be smarter tomorrow — incorporating new information would require recomputing gradients across the entire network, risking degradation of existing capabilities, and necessitating computational resources equivalent to partial retraining.
5. Insufficient Alternatives.
Fine-Tuning and LoRA: Parameter-efficient methods allow models to specialize, but they still require compute, training cycles, and do not scale to daily updates. Traditional fine-tuning updates all model parameters, requiring similar memory and computational resources as pre-training, though for fewer epochs. This process typically needs multiple GPUs, hours to days of training time, and careful hyperparameter tuning to prevent overfitting or catastrophic forgetting. LoRA (Low-Rank Adaptation) reduces computational overhead by freezing the original model weights and training only low-rank decomposition matrices, typically reducing trainable parameters to less than 1% of the model size. While LoRA matrices might only require megabytes of storage, the training process still demands loading the full model into memory for forward passes, computing gradients, and updating the adapter weights.
Other parameter-efficient fine-tuning (PEFT) methods like prefix tuning, prompt tuning, and adapter layers face similar constraints. These techniques require batch processing of training data, multiple epochs for convergence, and validation cycles to ensure quality. Even with these optimizations, the training pipeline involves data preprocessing, tokenization, batching, and gradient accumulation steps that cannot operate in real-time. The fundamental limitation remains: these methods require discrete training sessions with defined datasets, making continuous streaming updates impossible.
Alignment and Distillation: Techniques like reinforcement learning from human feedback (RLHF) or knowledge distillation refine model behavior but do not provide continuous factual updates. RLHF involves training a reward model from human preferences, then using reinforcement learning algorithms like Proximal Policy Optimization (PPO) to align the language model’s outputs with human values. This process requires collecting preference data, training the reward model, and running multiple iterations of policy optimization — a pipeline that takes days to weeks. The resulting model exhibits improved helpfulness, harmlessness, and honesty but gains no new factual knowledge beyond its original training. Knowledge distillation transfers capabilities from larger teacher models to smaller student models through techniques like logit matching, feature matching, or attention transfer.
The student model learns to mimic the teacher’s behavior on a transfer dataset, achieving compression ratios of 10-100x while retaining much of the performance. However, distillation cannot add information not present in the teacher model and requires a complete training cycle on the distillation dataset. Constitutional AI, instruction tuning, and other alignment methods similarly modify how models use their existing knowledge rather than updating that knowledge itself. These techniques optimize for output quality, safety, and task performance but operate within the constraints of the model’s frozen knowledge cutoff.
Conclusion: None of these methods resolve the fundamental barrier: LLMs cannot absorb streaming data in real time. Each approach requires batch processing, gradient computation, and parameter updates that take hours to days even with optimized techniques. The computational pipeline — from data ingestion through tokenization, batching, forward passes, backpropagation, and parameter updates — inherently operates in discrete cycles incompatible with continuous learning. Memory constraints, the need for gradient accumulation, and the risk of catastrophic forgetting further prevent incremental updates. Without fundamental architectural changes that separate reasoning capabilities from knowledge storage, LLMs remain static artifacts that must be entirely retrained or augmented with external retrieval systems to incorporate new information.
6. Retrieval-Augmented Generation as the Only Answer.
Retrieval augmented generation (RAG) provides a solution that fundamentally reimagines how language models access and utilize knowledge. Rather than encoding all information in model parameters through expensive training, RAG architectures maintain a clear separation between the model’s reasoning capabilities and its knowledge base. This paradigm shift enables dynamic knowledge updates while preserving the computational efficiency of inference.
a) Data ingestion:
New documents or incident records are embedded into vectors using specialized encoder models, typically based on transformer architectures optimized for semantic similarity rather than generation. These encoders, such as BERT-based models or sentence transformers, map variable-length text into fixed-dimensional dense vectors, usually ranging from 384 to 1536 dimensions. The embedding process preserves semantic meaning through training on contrastive objectives, where similar texts are pushed closer in vector space while dissimilar texts are separated. This transformation occurs in near real-time, requiring only a single forward pass through the encoder model, which typically takes milliseconds for documents of reasonable length. The embedding pipeline can process documents in parallel, enabling high-throughput ingestion of thousands of documents per second on modern hardware.
Preprocessing steps include text chunking to respect token limits, with strategies like sliding windows or semantic segmentation ensuring important context isn’t lost at chunk boundaries.
b) Vector storage:
These embeddings are stored in a database that supports similarity search through specialized indexing structures optimized for high-dimensional vectors. Modern vector databases implement approximate nearest neighbor (ANN) algorithms that trade perfect accuracy for dramatic speed improvements, achieving sub-linear search complexity. Popular indexing methods include Hierarchical Navigable Small World (HNSW) graphs that build multi-layer proximity graphs for efficient traversal, Locality-Sensitive Hashing (LSH) that maps similar vectors to the same hash buckets with high probability, and Inverted File Indexes (IVF) that partition the vector space into Voronoi cells for faster search. These databases support various distance metrics including cosine similarity for normalized vectors, Euclidean distance for absolute positioning, and dot product for maximum inner product search. The storage layer handles millions to billions of vectors while maintaining millisecond query latencies through techniques like quantization, which reduces memory footprint by representing vectors with fewer bits, and sharding, which distributes the index across multiple machines for horizontal scaling.
c) Contextual reasoning:
At inference, the model retrieves relevant entries and integrates them into its response through a multi-stage process that combines retrieval and generation. The query first gets embedded using the same encoder that processed the knowledge base, ensuring compatibility in vector space. The retrieval system then identifies the k most similar documents, typically using a two-stage approach: a fast approximate search to identify candidates, followed by optional reranking using more sophisticated models that consider cross-attention between query and document. Retrieved documents are injected into the language model’s context window, with careful prompt engineering to distinguish between retrieved knowledge and the user query. The model leverages its pre-trained in-context learning abilities to synthesize information from multiple retrieved passages, resolve contradictions, and generate coherent responses grounded in the retrieved evidence.
Advanced techniques include iterative retrieval, where the model can request additional information mid-generation, and attribution mechanisms that link generated claims back to specific retrieved sources.
This method allows new knowledge to be actionable within minutes of ingestion, without retraining. The entire pipeline from document ingestion through embedding, indexing, and availability for retrieval typically completes in seconds to minutes depending on document volume and system load. Unlike traditional training that requires batch accumulation, gradient computation, and parameter updates over multiple epochs, RAG systems achieve immediate knowledge integration through simple database operations. This architecture also provides natural versioning and rollback capabilities, as document collections can be timestamped, archived, and restored without affecting model parameters.
7. Reflex: A Case Study in Cybersecurity.
Reflex operationalizes RAG for incident response. Skills, tools, communications, and outcomes from incidents are embedded and stored. A vector DB provides immediate retrieval of semantically similar incidents. A large LLM synthesizes retrieved data into actionable intelligence, and candidate matches are evaluated for relevance and accuracy.
The RAG architecture fundamentally decouples reasoning from knowledge storage, utilizing the LLM’s pre-trained capabilities for language understanding, logical reasoning, and generation while delegating factual knowledge to external retrieval systems. Embedding models transform text into high-dimensional vector representations, typically using transformer-based encoders that map semantically similar content to nearby points in vector space. These embeddings capture semantic relationships through dense representations of 384 to 1536 dimensions, trained on contrastive learning objectives that maximize similarity between related texts while minimizing similarity between unrelated ones. Vector databases employ approximate nearest neighbor (ANN) algorithms like Hierarchical Navigable Small World (HNSW) graphs, Locality-Sensitive Hashing (LSH), or Inverted File Index (IVF) to enable sub-linear time complexity searches across millions of vectors. Similarity metrics such as cosine similarity, Euclidean distance, or dot product determine the relevance ranking of retrieved documents.
The retrieval process typically implements a two-stage architecture: a fast retriever that identifies candidate documents using vector similarity, followed by a reranker that applies more sophisticated scoring using cross-attention mechanisms or learned ranking functions. The LLM processes retrieved context through its attention mechanism, with the context window accommodating both the user query and relevant retrieved passages. Prompt engineering techniques position retrieved information optimally within the context to maximize the model’s ability to synthesize accurate responses. The generation process leverages in-context learning, where the model conditions its outputs on the retrieved evidence without updating its parameters.
By design, Reflex grows more effective with each incident. The AI used by advanced Reflex technology “learns” through accumulation and retrieval, not through parameter retraining. This AI is not hardwired into Reflex and can be used in the same way ChatGPT or Claude can be used. The limitation is that it is based on a much smaller model. It knows more about information security (real life information) than any other model. But the scope of what it knows is much less.
8. Why the Reflex Bridge’s Architecture Is Unavoidable.
The limits of current AI dictate the Reflex Bridge’s design. Compute reality: Retraining daily on new incident data is impossible. Full model retraining requires thousands of GPU-hours, with costs ranging from hundreds of thousands to millions of dollars per training run. Even incremental training approaches face prohibitive computational barriers: gradient computation scales with model size (O(n) where n is parameter count), backward passes require storing intermediate activations consuming terabytes of memory, and distributed training necessitates synchronization overhead that grows with cluster size. The energy consumption for continuous retraining would require dedicated power infrastructure, with large models consuming megawatts during training.
Hardware availability presents another constraint — the global shortage of high-performance GPUs means even well-funded organizations cannot secure sufficient compute for daily retraining cycles. Freshness requirement: Governments and enterprises cannot wait months for updated models. Operational environments demand response times measured in minutes or hours, not the weeks required for model retraining. Critical decisions in cybersecurity, healthcare, finance, and defense require immediate access to the latest information, patterns, and threat intelligence. The latency between data collection and model deployment in traditional training pipelines creates unacceptable vulnerability windows.
Maintainability: Vector DB updates are trivial compared to retraining. Adding new embeddings to a vector database requires only running the embedding model on new text (milliseconds to seconds) and inserting vectors into the index (microseconds to milliseconds). Index structures like HNSW support dynamic insertion without full reconstruction. Storage scales linearly with document count, typically requiring only gigabytes to terabytes rather than the petabytes needed for training datasets. Updates can be performed without downtime, using standard database techniques like write-ahead logging and atomic commits.
Version control, rollback, and incremental updates follow established database management practices. Future-proofing: the Reflex bridge remains base-model agnostic — when better open-source LLMs emerge, they can be swapped in seamlessly. The separation between retrieval and generation components allows independent upgrades of each system component. New embedding models can be deployed by recomputing vectors offline without disrupting service. Generation models can be replaced through standard API interfaces without modifying the retrieval pipeline.
This modularity enables organizations to benefit from advances in model architecture, training techniques, and parameter efficiency without architectural rewrites.
The Reflex Bridge process is not a compromise. It is the only architecture that respects the physics of today’s AI.
9. Implications for Governments and Enterprises.
Any organization seeking continuous, domain specific AI must adopt retrieval augmented methods. The computational economics of LLM deployment create insurmountable barriers for organizations attempting independent model training. Training a single 70B parameter model requires 1.7 million GPU-hours on A100-class hardware, translating to $3-10 million in cloud compute costs alone. This excludes expenses for data curation, annotation, engineering talent, and infrastructure maintenance. Even fine-tuning pre-trained models for domain specialization requires hundreds of thousands of dollars per iteration.
The expertise gap compounds these challenges — successful model training demands specialized knowledge in distributed systems, optimization algorithms, hyperparameter tuning, and ML engineering that remains scarce outside major AI research labs. Data requirements present additional obstacles: effective domain-specific training requires millions to billions of high-quality, domain-relevant tokens that many organizations cannot access or annotate. Attempts to build constantly updated domain specific LLMs will fail under present constraints. The retraining cycle fundamentally cannot match operational tempo — by the time a model completes training on Monday’s data, Friday’s critical information remains inaccessible. Catastrophic forgetting means each update risks degrading previously learned capabilities, creating regression cycles that undermine reliability.
The versioning nightmare of managing multiple model iterations across distributed deployments, ensuring compatibility, and coordinating updates becomes organizationally intractable. Legal and compliance requirements in regulated industries often mandate explainability and audit trails that black-box retraining cannot provide.
The Reflex Bridge demonstrates that independence, adaptability, and immediate usefulness are achievable today without impossible compute budgets. Retrieval-augmented architectures enable organizations to leverage existing open-source or commercial LLMs while maintaining complete control over their proprietary knowledge bases. The capital requirements shift from millions in GPU infrastructure to thousands in standard database and computing resources. Operational sovereignty is preserved — sensitive data remains within organizational boundaries, never leaving for external training facilities. Updates occur at the speed of data ingestion, with new knowledge available for retrieval within seconds to minutes rather than weeks to months.
The architectural pattern supports compliance requirements through traceable retrieval paths, source attribution, and audit logs of what information influenced each decision. Organizations can start with modest deployments and scale incrementally, adding compute and storage as needs grow rather than requiring massive upfront investment. The technology stack uses familiar components — databases, APIs, and standard infrastructure — that existing IT teams can manage without specialized ML expertise.
10. Conclusion.
Large language models cannot continuously learn from streaming data. The fundamental architecture of transformer-based models requires batch processing through forward and backward passes that cannot operate on single examples in real-time. The computational graph for backpropagation must maintain intermediate activations across all layers, consuming memory proportional to model size times batch size times sequence length. Gradient descent optimization requires multiple iterations over data to converge, with learning rates carefully scheduled to prevent instability or divergence. The stochastic nature of neural network training means single-example updates produce noisy gradients that destabilize learned representations.
Even advanced continual learning techniques like elastic weight consolidation (EWC), progressive neural networks, or memory replay cannot overcome the fundamental requirement for batch processing and iterative optimization. The economics and physics of training make it impossible to produce and distribute constantly updated domain specific models. Energy consumption for continuous training would require dedicated power plants — a single training run for a large model consumes as much electricity as dozens of homes use annually. The carbon footprint implications make perpetual retraining environmentally unsustainable. Market dynamics concentrate advanced training capabilities among a handful of organizations with access to cutting-edge hardware, making domain-specific model development economically unviable for most enterprises.
The speed of light and network latency create physical limits on distributed training synchronization, while memory bandwidth bottlenecks constrain parameter update rates regardless of computational power.
The Reflex Bridge solves this not by fighting physics, but by aligning with it: separating reasoning from retrieval. This architectural separation mirrors successful patterns in computer science — from CPU caches to content delivery networks — where computation and storage are decoupled for efficiency. The retrieval component operates at database speeds, with updates requiring only vector insertion operations that complete in milliseconds. The reasoning component leverages pre-trained transformers’ emergent capabilities for in-context learning, treating retrieved information as conditioning context rather than requiring parameter updates. This design respects the thermodynamic limits of computation while exploiting the asymmetry between inference (fast, parallelizable) and training (slow, sequential).
In this architecture, knowledge is always current, responses are always relevant, and the system remains independent of throttled external services.
This is not a compromise. It is the only way.
References.
Note: The following works are cited as canonical supporting literature. They represent widely recognized contributions in the field of AI and machine learning. They were not directly consulted in the drafting of this paper but are provided to anchor the discussion in established research. Yes, not only did I invent the first commercially available AI, anticipate the current AI and design Reflex technology 10 years before it was a reality, I created The Reflex Bridge That will bring the current AI into entirely new types of data (I didn’t build the LLM AI or embedding tools or vector database, of course). An AI did edit my paper from the way I describe things into what you might understand. If you’ve got it, use it. I could be drooling in a nursing home. There but for the grace of God go I 😊
– Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., … Amodei, D. (2020). Language Models are Few‑Shot Learners.
Advances in Neural Information Processing Systems, 33, 1877–1901.
– Devlin, J., Chang, M.‑W., Lee, K., & Toutanova, K. (2019). BERT: Pre‑training of Deep Bidirectional Transformers for Language Understanding. Proceedings of NAACL‑HLT, 4171–4186.
– Hu, E. J., Shen, Y., Wallis, P., Allen‑Zhu, Z., Li, Y., Wang, L., … Chen, W.
(2022). LoRA: Low‑Rank Adaptation of Large Language Models. arXiv preprint arXiv:2106.09685.
– Izsak, P., Berant, J., & Dagan, I. (2021). Semantic Retrieval for Question Answering.
Transactions of the Association for Computational Linguistics, 9, 1446–1460.
– Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., … Riedel, S. (2020). Retrieval‑Augmented Generation for Knowledge‑Intensive NLP Tasks. Advances in Neural Information Processing Systems, 33, 9459–9474.
– Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., & Sutskever, I. (2019).
Language Models are Unsupervised Multitask Learners. OpenAI Technical Report.
– Team, OpenAI. (2023). GPT‑4 Technical Report. arXiv preprint arXiv:2303.08774.
– Touvron, H., Martin, L., Stone, K., Albert, P., Almahairi, A., Babaei, Y., … Scialom, T.
(2023). LLaMA: Open and Efficient Foundation Language Models. arXiv preprint arXiv:2302.13971.