Natural Language Processing
Natural language processing is a branch of artificial intelligence that enables computers to read, interpret, and generate human language in text or speech form. It powers search engines, translation services, chatbots, voice assistants, and text analytics tools.
itArtificial intelligence and machine learning | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Natural Language Processing
Natural language processing is the set of techniques that let machines read, generate, and reason about human language — the same stuff you use every time you search the web, ask a voice assistant a question, or receive an auto-generated summary. Most of the world's data is unstructured text: emails, documents, medical records, social media posts. NLP exists to make that data computable.
Before NLP, a machine treated language as opaque character sequences. With NLP, it can detect entities, resolve references, classify documents, translate between languages, and produce coherent text. The field has been through three eras, and knowing which one you are in saves you from the mistakes each one made.
Rule-based systems (1950s–1990s) were grammars and dictionaries written by hand. They worked in the small worlds their authors specified and failed completely outside them. Statistical methods (1990s–2013) replaced hand-crafted rules with probabilities learned from large corpora. Coverage improved, but someone still had to design the features. Neural and pretrained models (2013–present) — Word2Vec, BERT, GPT, and the Transformer architecture behind them — learn representations directly from raw text, and that is where the field has been ever since.
The Transformer (2017) is the idea everything else hangs off. Instead of reading text one word at a time like older recurrent networks, a Transformer uses self-attention to let every word attend to every other word simultaneously. This enables massive parallelism during training and handles long-range dependencies naturally. Every major model you will encounter — BERT, GPT, T5, LLaMA — is a Transformer.
Two paradigms emerged. BERT reads text bidirectionally and excels at understanding: classification, entity recognition, question answering. GPT reads left to right and excels at generation: text completion, instruction following, creative tasks. They differ in training objective and attention mask, not in architecture. Knowing which one you need saves you from fine-tuning a generator to do classification or prompting an encoder to write prose.
The one thing that will surprise you: fluency is not truthfulness. Generative models produce text that reads as if a human wrote it, and that includes sentences that are factually wrong, hallucinated, or subtly biased by their training data. Evaluation is harder in NLP than in many other fields — automated metrics are imperfect proxies, and human evaluation remains the gold standard for generation tasks.
What to read next: the Slides tab maps the ecosystem and the decision points. The Reference tab is the study path. The Field Notes tab tells you what it actually costs when teams get tokenization, evaluation, or model selection wrong. Start there if you want to skip the theory and go straight to the parts that bite.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://web.stanford.edu/class/cs224n/index.html
Supports
- NLP enables machines to read, interpret, and generate human language in text or speech form
- https://arxiv.org/abs/1706.03762
Supports
- The Transformer architecture uses self-attention to process all positions in parallel, introduced in 2017
- https://arxiv.org/abs/1810.04805
Supports
- BERT uses masked language modeling to learn bidirectional contextual representations
- https://web.stanford.edu/class/cs224n/index.html
Supports
- GPT uses causal (left-to-right) language modeling to predict the next token from preceding context
- https://web.stanford.edu/class/cs224n/index.html
Supports
- Word2Vec and GloVe learn static dense vector representations where semantically similar words are near each other
- https://huggingface.co/learn/nlp-course
Supports
- BPE tokenization iteratively merges frequent byte pairs to create a subword vocabulary
- https://web.stanford.edu/class/cs224n/index.html
Supports
- BLEU measures translation quality based on n-gram precision with a brevity penalty
- https://arxiv.org/abs/1706.03762
Supports
- Self-attention computes scores as dot product of query and key vectors divided by square root of dimension
- https://arxiv.org/abs/2005.11401
Supports
- Retrieval-augmented generation combines a retriever with a generator to ground outputs in source documents
- https://web.stanford.edu/class/cs224n/index.html
Supports
- ELMo introduced context-dependent word representations using bidirectional LSTMs
- https://arxiv.org/abs/1706.03762
Supports
- Attention in seq2seq models lets the decoder focus on relevant encoder positions at each generation step
- https://arxiv.org/abs/1810.04805
Supports
- Fine-tuning adapts a pretrained model to a downstream task using task-specific labeled data
- https://web.stanford.edu/class/cs224n/index.html
Supports
- Language models trained on human text can reproduce and amplify biases present in training data
- https://arxiv.org/abs/1706.03762
Supports
- Attention cost grows quadratically with sequence length in standard Transformer implementations
- https://en.wikipedia.org/wiki/Computing_Machinery_and_Intelligence
Supports
- Alan Turing proposed the imitation game as a criterion for machine intelligence in 1950
- https://en.wikipedia.org/wiki/history_of_natural_language_processing
Supports
- The 1954 Georgetown-IBM experiment automatically translated 60 Russian sentences into English using six grammar rules
- https://en.wikipedia.org/wiki/ELIZA
Supports
- ELIZA simulated a psychotherapist using pattern matching and substitution, demonstrating conversational illusion without understanding
- https://en.wikipedia.org/wiki/SHRDLU
Supports
- SHRDLU understood and executed English commands within a simulated blocks world, showing structured natural language input was tractable in constrained domains
- https://en.wikipedia.org/wiki/history_of_natural_language_processing
Supports
- The Elman network (1990) encoded words as fixed vectors, introducing the first practical neural word embeddings
- https://en.wikipedia.org/wiki/history_of_natural_language_processing
Supports
- IBM alignment models (1993) replaced hand-coded translation rules with statistics learned from parallel corpora
- https://en.wikipedia.org/wiki/history_of_natural_language_processing
Supports
- Bengio's neural probabilistic language model (2003) showed learning distributed word representations jointly with a sequence model generalized better than n-grams
- https://arxiv.org/abs/1301.3781
Supports
- Word2Vec (2013) trained skip-gram and CBOW models on massive corpora, making semantic vector representations of words widely accessible
- https://arxiv.org/abs/1409.0473
Supports
- Bahdanau attention (2014) let decoders attend to all encoder states rather than a single fixed-length vector, fixing the bottleneck in sequence-to-sequence models
- https://arxiv.org/abs/2005.14165
Supports
- GPT-3 (2020) at 175 billion parameters demonstrated few-shot in-context learning, establishing the foundation model paradigm
- https://openai.com/index/chatgpt/
Supports
- OpenAI's ChatGPT (2022) combined GPT-3.5 with RLHF-based instruction tuning, reaching 100 million users in two months
- https://arxiv.org/abs/2302.13971
Supports
- Meta's LLaMA and open-weight derivatives showed model quality was no longer gated by proprietary access
- https://msphere.io/insights/nlp-pipelines-production/
Supports
- Tokenizer mismatch between training and serving produces silently corrupted embeddings; serialize and version the tokenizer artifact alongside the model
- https://www.ciopages.com/buyer-guides/natural-language-processing
Supports
- A task-tuned small model runs an order of magnitude cheaper and faster than a general-purpose LLM for narrow tasks at scale
- https://msphere.io/insights/nlp-pipelines-production/
Supports
- Benchmark F1 scores measured on curated data routinely degrade on production text containing encoding variations, domain jargon, and entity formats absent from the training set
