Untitled Flashcards Set

Chatbot Terminology (Case Study: The Perfect Chatbot)

• Chatbot latency
  The time delay between when a user submits a query to a chatbot and when the chatbot returns a response. High latency (e.g. 10 s in a bank’s chatbot) harms user satisfaction by making interactions feel sluggish.

• Linguistic nuance
  Subtle variations in language—such as tone, idioms, slang, and cultural references—that affect meaning. Handling these nuances helps a chatbot interpret ambiguous or informal user inputs accurately.

• Lexical analysis
  The initial NLP step that segments raw text into tokens (words, numbers, punctuation). It’s essential for downstream parsing and understanding.

• Syntactic analysis
  Also called parsing; it examines token sequences against grammatical rules to build a parse tree, revealing sentence structure.

• Semantic analysis
  The process of interpreting the meaning of tokens and their relationships, producing representations (e.g. semantic frames) that capture intent.

• Pragmatic analysis
  Understanding language in context—examining user intent, conversational history, and real‑world knowledge to resolve ambiguity.

• Model training
  The process of iteratively adjusting an AI model’s parameters on a labeled dataset so it learns to map inputs (e.g. user queries) to outputs (e.g. responses). Dataset size and quality critically influence accuracy.

• Backpropagation
  A learning algorithm for neural networks that propagates the error gradient from output back through each layer, updating weights to minimize loss. This underpins improvements in chatbot accuracy.

• Static dataset
  A fixed collection of training data that does not change once the model is deployed. Useful for stable performance but cannot adapt to new trends.

• Dynamic dataset
  A continuously updated dataset that incorporates new examples (e.g. fresh user chats), allowing the chatbot to evolve and stay current.

• Parallel processing
  Executing multiple computations simultaneously (e.g. on multi‑core CPUs or across machines) to reduce response time under heavy load.

• Knowledge distillation
  The technique of training a smaller “student” model to mimic a larger “teacher” model’s behavior, yielding a lightweight chatbot that retains most of the larger model’s accuracy.

• Embedding layer
  A neural network layer that maps discrete tokens (words) to continuous vectors in a high‑dimensional space, capturing semantic relationships for improved text processing.

• Explainability
  The degree to which a model’s internal reasoning can be understood by humans. In chatbots, transparent decision paths (e.g. attention scores) build user trust.

• Transfer learning
  Applying knowledge learned in one domain (pre‑trained language models) to a related task (fine‑tuning for customer support), reducing required training data and time.

• Intent recognition
  The NLP task of classifying a user’s overall goal or purpose (e.g. “book flight”, “reset password”) from their input text.

• Entity recognition
  Also Named Entity Recognition (NER); identifying and classifying key information units (e.g. names, dates, locations) within text.

• Reinforcement learning
  A learning paradigm where the chatbot improves by receiving rewards or penalties based on the quality of its responses, enabling long‑term conversational optimization.

• Knowledge graph
  A structured database of entities and their relationships, which a chatbot can query to retrieve accurate, up‑to‑date facts.

• Speech‑to‑text processing
  Converting spoken language into written text via acoustic and language models; extends chatbots to voice interfaces but must handle noise and pronunciation variability.

• GPU (Graphics Processing Unit)
  A specialized processor with thousands of cores optimized for parallel numeric computations, greatly accelerating large‑scale neural network inference compared to CPU‑only setups.

• TPU (Tensor Processing Unit)
  A custom Google‐designed ASIC for tensor operations in machine learning workloads, offering higher throughput and energy efficiency for inference and training.

• CPU (Central Processing Unit)
  The general‑purpose processor that executes program instructions sequentially; less efficient than GPUs/TPUs for large matrix operations common in NLP.

• Tokenization
  Breaking text into smaller units—words, subwords, or characters—serving as the first step in NLP. Choices (word‑based vs. character‑based vs. subword‑based) impact model size and handling of unknown words.

• Word‑based tokenization
  Splitting text on whitespace/punctuation into whole words; simple but struggles with rare or compound words.

• Character‑based tokenization
  Splitting text into individual characters; handles any input but results in long sequences and slower training.

• Subword‑based tokenization
  Splitting text into frequently occurring character n‑grams (e.g. Byte Pair Encoding); balances vocabulary size with capability to handle unknown words.

• Named Entity Recognition (NER)
  Extracting and classifying real‑world entities (persons, organizations, dates) from text, enhancing a chatbot’s ability to answer fact‑based queries.

• Sentiment Analysis
  Automatically detecting the emotional tone (positive, negative, neutral) of user input, allowing chatbots to adjust responses according to user mood.

• Deterministic rule‑based chatbot
  A chatbot that follows predefined rules and decision trees; predictable but inflexible, often failing when user input deviates from expected patterns.

• Probabilistic machine learning chatbot
  A chatbot that uses statistical or neural models to generate responses based on learned patterns; more flexible but can produce unexpected outputs.

• Edge computing
  Performing data processing (e.g. inference) on devices at the network edge (e.g. mobile phones) instead of centralized servers, reducing latency and bandwidth use.

• Cloud‑based infrastructure
  Hosting chatbot services on remote data centers accessed via the Internet; easily scalable but may incur higher latency and costs.

• On‑premises computing
  Running chatbot services on local servers owned by the organization; offers low latency and full control but requires upfront hardware investment.

OOP Terminology (Topic D OOP)

• Class
  A blueprint that defines data (attributes) and behaviors (methods) for objects. Classes enable structured, reusable code.

• Object
  An instance of a class containing concrete values for its attributes and ready to execute its methods.

• Encapsulation
  The OOP principle of restricting direct access to an object’s internal state (making variables private) and exposing operations through public methods (getters/setters), improving maintainability and security.

• Instance variable
  A variable defined in a class for which each object gets its own copy, representing the object’s state.

• Getter method
  A public method that returns the value of a private instance variable, allowing controlled read access.

• Setter method
  A public method that sets or updates the value of a private instance variable, allowing controlled write access.

• Inheritance
  The mechanism by which one class (subclass) acquires attributes and methods from another (superclass), promoting code reuse and logical hierarchy.

• Polymorphism
  The ability of different classes to be treated through the same interface—methods like draw() can behave differently in Circle, Rectangle, and Triangle subclasses.

• Abstract method
  A method declared without implementation in a base class, forcing subclasses to provide concrete behavior (e.g. draw() in a Shape class).

• Refactoring
  Restructuring existing code (e.g. merging Student and Teacher into a Person superclass) without changing external behavior, to improve readability and reduce duplication.

• Composition
  Building complex types by including instances of other classes (has‑a relationships) rather than inheriting from them, offering greater flexibility than inheritance alone.

• Modular programming
  Designing software as a collection of loosely coupled, self‑contained components (modules) that can be developed, tested, and maintained independently.

• Monolithic design
  A non‑modular approach where all functionality resides in a single codebase or module, often leading to maintenance and scaling challenges.

• Static method
  A method associated with the class rather than any instance; it cannot access instance variables and is called on the class itself.

• Instance method
  A method that operates on a specific object’s instance variables and can only be called through an object.

• Interface
  In languages like Java, an abstract type that declares method signatures without implementations, enabling multiple inheritance of behavior contracts.

• Method overriding
  A subclass’s ability to provide a specific implementation for a method already defined in its superclass, altering or extending the inherited behavior.

• Method overloading
  Defining multiple methods with the same name but different parameter lists within the same class, enhancing readability and flexibility.

• Design pattern
  A general, reusable solution template for common software design problems (e.g. Singleton, Factory, Observer) that promotes best practices.

• Singleton pattern
  Ensures a class has only one instance and provides a global access point to it, useful for shared resources like configuration managers.

• Factory pattern
  Encapsulates object creation logic in a separate factory class or method, enabling easy substitution of concrete implementations without changing client code.

• Observer pattern
  Defines a one‑to‑many dependency so that when one object’s state changes, all its dependents (observers) are notified and updated automatically.

• Data hiding
  Another term for encapsulation; preventing external code from directly accessing an object’s internal data to preserve invariants and integrity.

• Procedural programming
  A programming paradigm based on procedures or routines (functions) rather than objects; contrasts with OOP by organizing code around actions rather than data.

Feel free to let me know if you’d like any more cards or deeper examples!