Bias​

• Bias quantifies how much on average the predicted values differ from the actual values.
• High bias implies the model is under-performing.

Variance​

• Variance quantifies how sensitive the model is to small changes in the training samples.

Ensemble Methods​

• The intuition behind ensemble methods is to decrease bias and variance by using multiple machine learning algorithms.
• Any machine learning algorithm can be used in ensemble methods.
  • decision trees, neural networks, logistic regressions, etc.
• Base models are as diverse as possible.
• Train each base model to predict as accurately as possible.

Sequential ensemble methods​

• Arrange weak learners in a sequence, such that weak learners learn from next learner in the sequence to create better predictive models.
• Each model fits the residual of its predecessor.

Parallel ensemble methods​

• to use different variations of the same dataset, of the smae classifier, and aggregate the results.

Bootstraping​

• Sampling technique that creates multiple subsets of datasets from the original dataset.
• when inferring results for a population from results found on a collection of smaller random samples of that population.

Bagging​

Bootstrap aggregating

• Generates subsets (bags) of traning data by sampling from the original training dataset with replacement.
• To overcome the complexity of models that overfit the training data.

Boosting​

• fits multiple models sequentially
• each model in the sequence is fitted giving more weight to the data points that were poorly handled by the previous models in the sequence.
• This process is iterated until the error function does not change, or the maximum limit of the number of estimators is reached.

Random Forest​

• Shallow trees have lower variance and higher bias, whereas deep trees have low bias but high variance.
  • Shallow trees are chosen for sequential ensemble methods
  • Deep trees are chosen for bagging methods (or parallel ensemble methods).
• a bagging method where deep trees are used and fitted on bootstrap samples, and then combined to produce an output with lower variance.
• selects randomly a set of features which are then used to decide the best split at each node of the tree.
• can be applied to both regression and classification tasks.
• can learn binary features, categorical features and numerical features.

1. create from the original dataset multiple bootstrap samples.
2. at each node in the decision tree, a random set of features is considered to decide the most beneficial split.
3. train a decision tree on each bootstrap sample.
4. final prediction is computed by averaging the prediction from all decision trees combined.

Advantages of Random Forest​

• generally accurate, quick to train
• can handle very large datasets
• can estimate importance of features
• generates an internal unbiased estimate of accuracy, which can use to know when to stop buildling
• can handle missing data
• can handle datasets with imbalanced classes
• can compute proximity between data points
• unsupervised for clustering and outlier detection

but don't handle large numbers of irrelevant attributes as well as some other methods.

Applications of Random Forest​

AdaBoost​

Adaptive Boosting

• simplest boosting algorithm, usaully uses decision trees for modelling
• multiple sequential models are created, each correcting the errors from the previous model.

GBM​

Gradient Boosting Machine

• works on both regression and classification problems.
• usually, regression trees are used as base models.

XGBoost​

eXtreme Gradient Boosting

• another implementation of gradient boosting algorithm.
• has proven to be a highly effective machine learning algorithm.
• extensively used in machine learning competitions due to its speed and performance.

Combining predictions​

Voting​

• Hard voting selection process uses predicted class labels for majority rule voting.
• Soft voting uses the predicted probabilities given by each base model, and the class label with the maximum sum of its probabilities is selected.
  • $\frac{1}{N} \sum_{i=1}^{N} P_{i}(c|x)$
  • where $N$ is the number of base models, and $P_{i}(c|x)$ is the probability predicted by model $i$ for class $c$ given input $x$.

Exception​

• Exeptions are throwable objects.
• Checked Exceptions are checked by the compiler and should be handled (thrown or caught).
• Unchecked or runtime Exceptions are not flagged by the compiler. Their occurrence during execution interrupts the program.
• Exceptions can be thrown by developers. Throwing an exception delegates handling the exception to a different class or different level of the program.
• Thrown exception is left not handled, it will cause runtime error.

Error​

• Java Errors usually indicate problems with the JVM or system resources.
  • it is not meant to be caught or handled by applications.
  • the base class is Error.
• Python is no separate Error class hierarchy. Errors are represented as exceptions.
  • ValueError, TypeError, MemoryError, SystemError, etc. are subclasses of Exception.

Java vs Pythone Exceiptions​

public class ExceptionExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.print("Enter first number: ");
            int a = scanner.nextInt();
            System.out.print("Enter second number: ");
            int b = scanner.nextInt();
            int result = a / b; // This will raise ArithmeticException
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught an exception: " + e.getMessage());
        } catch (NumberFormatException e) {
            System.out.println("Caught a number format exception: " + e.getMessage());
        } finally {
            System.out.println("This block always executes.");
        }
    }
}

def div(a, b):
    return a / b

a = input("Enter first number: ")
b = input("Enter second number: ")

try:
    result = div(int(a), int(b))  # This will raise ZeroDivisionError
    print("Result:", result)
except ZeroDivisionError as e:
    print("Caught an exception:", e)
except ValueError as e:
    print("Caught a value error:", e)
else:
    print("No exception occurred.")
finally:
    print("This block always executes.")

Throwing Exceptions​

class IncorrectAgeError(Exception):
    def __init__(self, age):
        self.age = age
        self.message = f"Age {age} is not valid. Age must be between 0 and 120."
        super().__init__(self.message)

number = int(input("Enter your age: "))

try:
    if number < 0 or number > 120:
        raise IncorrectAgeError(number)
    print(f"Your age is {number}.")
except IncorrectAgeError as e:
    print(e)

File Handlers​

• "r": Opens a file for reading, requires the file to exist
• "w": Opens a file for writing. If the file exists, it is truncated to zero length. If the file does not exist, a new text file is created.
• "a": Opens file for open for writing. The file is created if it does not exist.
• "+": Opens a file in updating mode (reading and writing). It can be used with reading (r+) and writing (w+) modes.
• "t": Opens a file in text mode (default mode).
• "b": Opens a file in binary mode. It can be used with reading (rb) and writing (wb) modes.

File Handler Methods​

os.path.exists("file.txt")  # Check if file exists
os.remove("file.txt")  # Delete a file
os.remove("dir")  # Delete an empty directory
os.chdir("path/dir")  # Change current working directory
os.getcwd()  # Get current working directory
os.mkdir("path/dir")  # Create a new directory

file_handler = open("file.txt", "r")  # Open a file in read mode
file_handler.read()  # Read the entire file content
file_handler.readline()  # Read a single line from the file
file_handler.close()  # Close the file

file_handler = open("file.txt", "w")  # Open a file in write mode
file_handler.write("Hello, World!")  # Write to the file
file_handler.write("\n")  # Write a newline character
file_handler.close()  # Close the file


import csv
with open("file.txt", "r") as file_handler:  # Using 'with' to handle file
    csv_object = csv.reader(file_handler)
    for row in csv_object:
        print(row)
    file_handler.close()

with open("file.txt", "a") as file_handler:  # Append mode
    csv_writer = csv.writer(file_handler)
    row = ["1", "gracefullight", "100"]
    csv_writer.writerow(row)
    file_handler.close()

import json
with open("data.json", "r") as file_handler:
    data = json.load(file_handler)  # Load JSON data from file
    print(data)
    file_handler.close()

with open("data.json", "w") as file_handler:
    json.dump(data, file_handler)  # Write JSON data to file
    file_handler.close()

• InputStream: reads byte-based input from various sources like files, memory, or network connections.
• OutputStream: writes byte-based output to various network connections.

Unit Testing​

• tests and verifies the smallest unis of an application such as functions, procedures, modules, or objects.
• the conducted during the development phase of the SDLC.
• Developers aim to identify defects and code bugs, which can save time and reduce costs in later testing stages.
• software testing encompasses the fourmain testing phases, and unit testing is at the foundational level of the process.
  • Unit Testing
  • Integration Testing
  • System Testing
  • Acceptance Testing

Python unit testing​

• test cases are defined using classes that inherit from unittest.TestCase
• assertions are used to validate results self.assertEquals()
• the unittest.TextTestRunner class can be used to run tests

import unittest

class TestMathOperations(unittest.TestCase):

    def test_addition(self):
        self.assertEqual(2 + 3, 5)

    def test_subtraction(self):
        self.assertEqual(5 - 2, 3)

    def test_multiplication(self):
        self.assertEqual(4 * 3, 12)

    def test_division(self):
        self.assertEqual(10 / 2, 5)

Knowledge representation​

• Intelligent agents need knowledge about the world in order to reach good decisions.
• Declarative knowledge is represented in a form of sentences in a knowledge representation language and stored in a knowledge base.
• Knowledge base is used by an inference engine to infer a new sentence which will be used for the agent to decide what action to take next.
• Formal languages are defined by its grammar and semantic rules
  • grammar: defines the syntax of legal sentences
  • semantic rules: defines the meaning.
• Common knowledge representation formalisms:
  • Propositional logic
  • First-order logic
  • Fuzzy logic
  • Semantic networks
  • Ontologies

Propositional logic​

• a declarative language in which can handle propositions that are known true, known false, or completely (unknown true or false)
• a BNK (Backus-Naur Form) grammer of sentences in propositional logic.
  • $\neg$ = NOT
  • $\land$ = AND
  • $\lor$ = OR
  • $\implies$ = IMPLIES
  • $\iff$ = IF AND ONLY IF
• Negation: a sentence using $\neg$ is called negation
• Literal: either an atomic sentence or a negated atomic sentence
• Conjunction: two sentences connected by $\land$. Eac hof them is called conjunct
• Disjunction: two sentences connected by $\lor$. Each of them is called disjunct
• Implication: two sentences connected by $\implies$. $P \implies Q$. P is called premise or antecedent and Q is the conclusion or consequent.
  • An implication is if-then statement.

Truth tables

FOL, First-order logic​

• a declarative language
• Syntax of FOL builds on that of propositional logic
• terms to represent objects, universal quantifier, and existential quantifier
• a model in FOL must provide the information required to determine the truth value of every atomic sentence in the language.
• $\forall x P(x)$ means for all x, P(x) is true
• $\exists x P(x)$ means there exists an x such that P(x) is true

Logical equivalence​

$\forall x \neg P(x) \equiv \neg \exists x P(x)$

• For all x, not P(x) is logically equivalent to "it is not the case that there exists an x such that P(x) is true."

Reasoning​

Deductive reasoning​

• a process of reasoning from one or more statements (premises) to reach a logical conclusion.
• first premise, second premise, therefore conclusion.

Inductive reasoning​

• the process of resoning from specific observations to borader generalizations and theories.
• also described as a method where one's experiences and observations are synthesized to cmoe up with a general truth.
• premises and then conclusion

Inference​

• steps in reasoning
• moves from premises to logical consequences
• In AI Context, inference is to derive new logical sentences (as the conclusion) from existing logical sentences (as premises).
• researchers develop automated inference systems to emulate human inference.

Inference Problem​

$KB \models \gamma$

• KB, Knowledge Base, is a set of propositions that represent what is known about the world.
• $\gamma$, Query sentence, is the target conclusion which needs to be confirmed based on the given KB.
• where $\models$ denotes the relation of logical entailment between KB and the sentence $\gamma$, reading as "KB entails $\gamma$" or "if KB is true, then $\gamma$ must also be true".
• $\alpha \models \beta \iff M(\alpha) \subseteq M(\beta)$
  • $M(\alpha)$ is the set of all models that satisfy $\alpha$.
  • $M(\beta)$ is the set of all models that satisfy $\beta$.
  • The statement $\alpha \models \beta$ means that in every model where $\alpha$ is true, $\beta$ is also true. In other words, if $\alpha$ holds, then $\beta$ must also hold.
• Model Checking: enumerates all possible models and checks if the entailment holds in each model.
  • Knowledge base will be used to draw inferences.
  • Query sentence, $\gamma$, is needed to be checked whether it is entailed by the KB.
  • Symbols, a list of all symbols (or atomic propositions) used in the problem context.
  • Models, assignments of truth and false values to those identified symbols.
• Model Checking Procedure
  1. Identify the propositional symbols involved in the KB sentences and query sentence
  2. Enumerate all possible models by assigning truth values to the identified symbols.
  3. Evaluate the KB sentence in each model and fined the models in which KB is true.
  4. Evaluate the query sentence in the models from step 3 and check if query sentence is true in these models.
  5. Conclude that the KB entails the query sentence $\gamma$ if and only if the query sentence is true in all models where the KB is true.

Inference Problem Example​

• Obersvation P: "It is raining"
• Query sentence Q: "The ground is wet"
• Knowledge: $P \implies Q$ (If it is raining, then the ground is wet)
• Knowledge Base KB: $P \land (P \implies Q)$
• Inference Problem: $KB \models Q$ from KB=T, get Q=T
• Proof:
  1. From the 4 possible models, only Model 1 makes KB true.
  2. M(KB) = model 1
  3. Model 1 also makes Q true.
  4. M(Q) = model 1
  5. $M(KB) \subseteq M(Q)$, therefore $KB \models Q$

Inference by theorem proving​

to apply rules of inference directly to the sentences in the KB to construct a proof of the desired sentence without consulting models.

• Proof: a chain of consequences that leads to the desired goal.
• KB will be used to draw inferences.
• Desired sentence is needed to be checked whether it is entailed by the KB.
• The rules of inference are the approved logical equivalences and rules.

Modus Ponens Rule​

$\frac{\alpha \implies \beta, \alpha}{\therefore \beta}$

• whenever any sentences of the form $\alpha \implies \beta$ and $\alpha$ are given, then the sentence $\beta$ can be inferred.

Add-Elimination Rule​

$\frac{\alpha \land \beta}{\therefore \alpha}$

• from a conjunction, one of the conjuncts can be inferred.

Terms to contradiction and resolution​

CNF
┌────────────────────────────────────────────────┐
│            (P ∨ Q)         ∧    (¬Q ∨ R)       │
│   ┌──────────────────────┐   ┌───────────────┐ │
│   │  Clause 1            │   │  Clause 2     │ │
│   │  (P ∨ Q)             │   │  (¬Q ∨ R)     │ │
│   │  ┌───────┬───────┐   │   │  ┌──────┬─────┐ │
│   │  │  P    │   Q   │   │   │  │ ¬Q   │  R  │ │
│   │  └───────┴───────┘   │   │  └──────┴─────┘ │
│   └──────────────────────┘   └───────────────┘ │
└────────────────────────────────────────────────┘

• Literal: an atomic sentence or its negation
• Complementary literals: a literal and its negation are complementary literals
• Clause: an expression formed from a collection of finite literals
  • In most $l_1 \lor l_2 \lor ... \lor l_n$ cases, a clause is a disjunction of finite literals.
  • written as the symbol $l_i$.
• Conjunctive Normal Form: a sentence expressed as a conjunction of clauses.
• Satisfiability: a sentence is satisfiable if it is true in, or satisfied by, some models.

Propositional satisfiability (SAT) problem​

• to determine the satisfiability of sentences in propositional logic.
• if there exists a model that satisfies a given logical sentence, then the sentence is satisfiable.
• Satisfiability can be checked by enumerating the possible models until one is found that satisfies the sentence, or by resolving complementary literals until an empty clause is derived.
• many problems in CS are really SAT problems.

Resolution rule​

Unit resolution rule​

$\frac{(l_1 \lor l_2 \lor ... \lor l_{i-1} \lor l_i \lor l_{i+1} \lor ... \lor l_k,\space m)}{l_1 \lor ... \lor l_{i-1} \lor l_{i+1} \lor ... \lor l_k}$

• where $l$ is a literal and $l_i$ and $m$ are complementary literals.
• Unit resolution rule takes a clause which is a disjunction of literals, and a literal and produces a new clause as the resolvent.

Full resolution rule​

$\frac{(l_1 \lor l_2 \lor ... \lor l_{i-1} \lor l_i \lor l_{i+1} \lor ... \lor l_k,\space m_1 \lor m_2 \lor ... \lor m_{j-1} \lor m_j \lor m_{j+1} \lor ... \lor m_n)}{(l_1 \lor ... \lor l_{i-1} \lor l_{i+1} \lor ... \lor l_k \lor m_1 \lor ... \lor m_{j-1} \lor m_{j+1} \lor ... \lor m_n)}$

• where $l$ is a literal and $l_i$ and $m_j$ are complementary literals.
• Full resolution rule takes two clauses which are disjuctions of literals and produces a new clause containing all the literals of the two original clauses except for the two complementary literals.

Inference via proof by contradiction through resolution​

$\alpha \models \beta$

• to prove that $\alpha \models \beta$, we can show that the sentence $\alpha \land \neg \beta$ is unsatisfiable.
• by deriving an empty clause $()$ from $\alpha \land \neg \beta$ using the resolution rule.
• In order to derive an empty clause, we use resolution which is a process to resolve complementary literals until to find an empty clause.
  1. R1: P (observation)
  2. R2: P $\implies$ Q (knowledge, raining implies ground is wet)
  3. $KB = P \land (P \implies Q)$
  4. Query sentence: Q
  5. Inference problem: $KB \models Q$, i.e. from $KB=T$, get $Q=T$
  6. Proof:
  • Let $(P \land (P \implies Q)) \land \neg Q$ valid
  • Convert $(P \land (P \implies Q)) \land \neg Q$ to CNF
  • Apply implication elimination rule, one has $(P \land (\neg P \lor Q)) \land \neg Q$
    • $C_1: P$
    • $C_2: \neg P \lor Q$
    • $C_3: \neg Q$
  • Apply unit resolution rule to $C_1$ and $C_2$, resolve $P$ and $\neg P$, one has $C_4: Q$
  • Apply unit resolution rule to $C_3$ and $C_4$, resolve $Q$ and $\neg Q$, one has $C_5: ()$

Inference in FOL​

• convert the first-order inference to propositional inference using the ruls for quantifiers.
  • universal instantiation (UI)
  • existential instantiation (EI)
• do inference in propositional logic using the methods about inference in propositional logic.
• this approach to first-order logic inference via propositionalization is complete, means any entailed sentences can be proved.
  • in most cases, this approach works
  • in some cases, it is slow and only useful when the domain is small.
• get rid of quantifiers by instantiating them with specific constants or variables.

Universal instantiation (UI)​

$\frac{\forall v \space \alpha}{\text{Subst}(\{v/g\},\alpha)}$

• to convert sentences with universal quantifiers to sentences without universal quantifiers.
• it can infer any sentence obtained by substituting a ground term for the universally quantified variable.
• $Subst(\{\theta, \alpha\})$ denotes the result of applying the subsitution $\theta$ to the sentence $\alpha$ and $g$ is a ground term or a constant symbol.
• universal instantiation can be applied many times to produce may different consequences.
• $\forall x Loves(x, Mary)$
  • $Loves(John, Mary)$
  • $Loves(Sue, Mary)$
  • $Loves(Bill, Mary)$
  • ...

Existential instantiation (EI)​

• to convert sentences with existential quantifiers to sentences without existential quantifiers.
• the quantified variable can be replaced by a single new constant symbol.
• for any sentence $\alpha$, variable $v$, and constant symbol $k$ not appear elsewhere in the knowldge base, the following rule is sound: $\frac{\exists v \space \alpha}{\text{Subst}(\{v/k\},\alpha)}$
• $\text{Subst}\{\theta, \alpha\}$ denotes the result of applying the subsitiution $\theta={v/k}$ in the sentence $\alpha$ and $k$ is ground term or a new constant symbol.
• Existential instantiation can be applied only once, and then the existentially quantified sentence can be discarded.
• $\exists x Loves(x, Mary)$
  • $Loves(K, Mary)$
  • where $K$ is a new constant symbol not appear elsewhere in the knowledge base

CNF, Conjunctive Normal Form​

Vocabulary & Expressions​

Ontology​

Semantic Network​

• Semantic networks let us represent logical relationships visually, but their meaning remains purely logical — about objects, categories, and relations.

Tractability​

Generative AI​

• Gen AI refers to a category of AI models designed to generte new content, synt99hetic data that resembles a given dataset.
• Gen AI models create new content, including text, images, audio, and video.

Historcal context of Gen AI​

• 1980s: The development of statistical approaches to AI emerged, focusing on probabilistic models
• 1990s: Hidden Markov Models (HMMs) became popular in speech recognition and sequence generation tasks, making a shift towards using statistical methods in generative processes.
• 1990s-2000s: The resurgence of Neural Networks, with the introduction of deep learning techniques. However, hardware and data limitations hampered progress.
• 2010s: The advent of deep learning algorithms, especially convolutional neural networks (CNNs) and recurrent neural networks (RNNs), transformed the landscape of AI.
• 2013: VAEs were introduced, providing a probabilistic approach to data generation, allowing for smooth latent space interpolation and structure.
• 2014: GANs, a novel framework where two neural networks (a generator and a discriminator) are trained simultaneously, allowing for the generation of highly realistic images and other data types.
• 2015-2020: Generative models began to find applications beyond image synthesis, including text generation, music composition, and even video generation. OpenAI's GPT-2 showcased the potential of transformer-based models for generating coherent text.
• 2020s: The introduction of larger and more capable models like OpenAI's GPT-3 and subsequent iterations revolutionized natural language processing.
  • DALL-E and Stable Diffusion pushed the boundaries of image generation, allowing users to create images from textual descriptions. This sparked creative exploration and practical applications in marketing, art, and design.
• Present: The integration of multiple data modalities (text, image, audio) led to the development of models like CLIP and GPT-4, which can understand and generate content across different formats, enhancing the versatility of generative AI.

Variational Autoencoders, VAEs​

• VAEs are from the probabilistic approach to build a generative AI model
• VAE learns a latent distribution instead of a fixed latent presentation, allowing for the generation of new samples.
• Latent space
  • sample from a Gaussian distribution
  • $\mu$ and $\sigma$ are learned during training
  • $z$ is a new sample from the latent space
• $q_\phi(z|x)$ is the encoder that maps input data $x$ to a distribution over the latent space $z$
• $p_\theta(x|z)$ is the decoder that maps a latent variable $z$ back to the data space $x$
• During training, the model optimizes the reconstruction loss and a regularization term (KL divergence) to ensure the learned latent distribution is close to a prior distribution (usually a standard normal distribution).
• Latent Representation
  • Dimensionality Reduction: latent space is typically lower-dimensional than the input space
  • Smoothness: In a well-structured latent space, similar inputs will be represented by nearby points.
  • Generative Capabilities: Once trained, can sample from the latent space to generate new data that resembles the training set.
  • Regularization: The VAE incorporates a regularization term in its loss function (KL divergence), which encourages the lerned latent distribution to be close to a standard normal distribution.
• Decoder
  • The decoder takes the sampled latent representation $z$ and reconstructs the original input data.
  • The goal is to make the reconstructed data as close as possible to the original input.

VAE Examples​

Face Generation Example​

• Trains a VAE on face photos.
• Latent space learns meaningful features (e.g. hair color, glasses, smile)
• By sampling and interpolating in latent space, can generate new faces or smoothly morph one face into another.

Anomaly Detection Example​

• Train a VAE on normal sensor data.
• When fed unusual data, reconstruction error will be high.
• Use this for fault detection in machines, fraud detction, etc.

Autoencoder​

• Encoder
  • Input Layer: takes in the original data
  • Hidden Layer: These layers progrssively reduce the dimensionality of the input through operations like linear transformations and non-linear activations. (e.g., ReLU-Rectified Linear Unit)
  • Ouput Layer: Produces the final latent represntation. Sometimes Sigmoid or Tanh are used depending on the nature of the input data.
  • Learns to capture meaningful patterns in the data by minimizaing reconstruction loss, which mesures the difference between the original input and the reconstructed output produced by the decoder.
• Decoder
  • typically mirrors the structure of the encoder but in reverse.
  • During trainng, Mean squared Error (MSE) for continuous data or Binary Cross-Entropy (BCE) for binary data are commonly used to quantify the reconstruction loss.

Image Reconstuction Example​

• input: 28x28 pixel
• encoder: compresses it to just 16 numbers (latent vector)
• decoder: expands those 16 numbers back into a 28x28 image
• result: the reconstructed digit looks similar to the original but not in the training set.

Denoising Images​

• input: a noisy photo of a cat
• encoder: learns to ignore the noise and compress meaningful features.
• decoder: rebuilds the image without the noise.
• output: a clearer cat image.

Loss function​

• Reconstruction loss: Ensure output similar to input
• KL divergence loss: Push the learned distribution to be close to a standard normal distribution. (can sample new data)

Generative Adversarial Network, GAN​

• Generator: Learns to generate fake (generated) data that resembles data distribution.
• Discriminator: Learns to distinguish between real data and data generated by the Generator.
• Steps
  1. Generator creates fake data samples fro mrandom input (noise).
  2. Discriminator evaludates these samples together with real data samples.
  3. Discriminator outputs probabilities indicatcing whether each sample is real or fake.
  4. Based on the prediction of the Discriminator, the Generator and Discriminator are updated using specific loss functions.
• Applications
  • Labels to Street Scenes
  • Labels to Facade
  • BW to Color
  • Aerial to Map
  • Day to Nihght
  • Edges to Photo
  • Text-to-Image Synthesis

Autoregressive Models​

• a class of generative models where the current value of a time series is expressed as a linear function of its own past values plus some noise.
• foundational in generative AI and widely used in generative AI, particularly for tasks like text generation, speech synthesis.
• Examples
  • GPT series: state-of-the-art autoregressive language models used for text generation.
  • WaveNet: an autoregressive model for generating high-quality audio by predicting each sample conditioned on previous samples.

Training Autoregressive Models​

• Pretraining
  • the model sees sequences of tokens and learns to guess the next token.
  • objective: minimize cross-entropy loss between its guess and the true next token.
  • this teaches grammar, facts, reasoning patterns, and style from raw text.
• Supervised fine-tuning (optional)
  • smaller curated datasets (questions to answer, instructions to respond) teach it to follow directions.
• Reinforcement learning from Human Feedback (optional)
  • Humans rank multiple model outputs; a reward model is trained on those rankings; GPT is then optimized to produce higher-reward responses (safer, more helpful, less toxic)
• Text to Tokens via a tokenizer (e.g. BPE, Byte Pair Encoding)
• Each token becomes a vector (Embedding)
• Positional encodings inject order information.
• Transformer layer
  • self-attention: each token looks at all previous token (causal mask) and decides which ones matter, computing weighted combinations.
  • Multiple heads let it attend to different patterns (syntax, long-range links, etc.).
  • feed-forward network: a nonlinear MLP refines each token's representation.
  • residual connections & layer norm stabilize tranining.

Interfence​

• a prompt (the context)
• GPT computes probabiliites for the next token.
• A decoding stragety samples a token
  • Decoding knobs
    • Greedy: take the top token
    • Top-K
    • Nucleus (Top-p) sampling (limit to likely options)
    • Temperature scales randomness, controls how random the next token choice is
      • lower = more determistic, higher = more creative
• append the token and repeat autoregressive generation.

SVM​

a supervised learning framework for finding a boundary between data points belonging to different classes.

Convex Hull​

• the lines surrounding the outermost points of each class.
• since the classes are linearly separable, convex hulls do not intersect.

Margins​

• the distance between data points of different classes seprarated by a hyperplane.
• multiple possible hyperplanes can separate the classes, but the optimal hyperplane maximizes the margin.
• Maximum Margin Hyperplane
  • a separation line/plane orthogonal to the shortest line connecting the convex hull.
  • the line that is farthest apart from each convex hull.
  • it separates the data points with the widest margin.

Kernels​

• kernel is used to represent kernel functions
  • which are used to convert low-dimensional space to high-dimensional space
  • by applying a function on low-dimensional data points to come up with higher dimensions
    • which can be used to linearly separate the data points of classes using a hyperplane.
• the function of a kernel is to take data as input and transform it into the required form.
  • different algorithms use different types of kernel functions.
  • linear, non-linear, polynomial, radial basis function (RBF), and sigmoid.

Kernel trick​

• Basic idea of SVM and Kernel trick is to find the plane which can separate, classify or split the data with maximum margin as possible.
• The distance from a point $(x_0, y_0)$ to a line $Ax + By + C = 0$ is given by the formula: $$\text{Distance} = \frac{|Ax_0 + By_0 + C|}{\sqrt{A^2 + B^2}}$$
• The distance between $H_0$, $H_1$ is then: $|w \cdot x + b| / ||w|| = 1/||w||$.
  • The total distance between $H_1$ and $H_2$ is $2/||w||$.
  • $H_1: w \cdot x + b = 1$
  • $H_2: w \cdot x + b = -1$.
  $$\text{Distance} = \frac{|(+1) - (-1)|}{||w||} = \frac{2}{||w||}$$
• to maximiza the margin, we need to minimize $||w||$
• this can be solved through Lagrangian formula or Lagrangian multipliers. $$L = \frac{1}{2} ||w||^2 - \sum_{i=1}^{n} \alpha_i [y_i (w \cdot x_i + b) - 1]$$
• Setting the gradient of $L$ $$\frac{\partial L}{\partial w} = 0 \Rightarrow w = \sum_{i=1}^{n} \alpha_i y_i x_i$$ $$\frac{\partial L}{\partial b} = 0 \Rightarrow \sum_{i=1}^{n} \alpha_i y_i = 0$$
• The dual form of the optimization problem is: $$\text{Maximize } W(\alpha) = \sum_{i=1}^{n} \alpha_i - \frac{1}{2} \sum_{i=1}^{n} \sum_{j=1}^{n} \alpha_i \alpha_j y_i y_j (x_i \cdot x_j)$$
• Capital letters such as A, X, Y denote matrices;
• Greek letters such as $\Phi$, $\kappa$ denote functions;
• lower-case bold letters such as $a$, $b$ denote vectors;
• script letters such as $\mathcal{A}$, $\mathcal{B}$, $\mathcal{V}$, $\mathcal{E}$ denote sets or spaces;
• $||a||$ denotes the $L^2$ norm of vector;
• $||x||_F$ denotes the Frobenius norm of matrix, and is given by $||x||_F = \big(\sum_{i,j} |x_{ij}|^2\big)^{1/2}$;

Linear Kernel​

$K(x_i, x_j) = x_i \cdot x_j$

Gaussian Kernel / RBF Kernel​

$K(x_i, x_j) = \exp\Big(-\frac{||x_i - x_j||^2}{2\sigma^2}\Big)$

Polynomial Kernel​

$K(x_i, x_j) = (x_i \cdot x_j + 1)^h$

Sequential Minimal Optimization (SMO)​

• an algorithm for solving the quadratic programming (QP) problem that arises during the training of support vector machines (SVMs).

Advantages​

• Overfitting is unlikely
  • SVM uses the maximum margin hyperplane, which is relatively stable.
  • the maximum margin hyperplane is only sensitive to the changes in the support vectors.
  • the variance in the data may have a relatively low effect on the performance
• Computational complexity
  • since every time we need to classify a new sample we need to examine that sample with all the support vectors.
  • Using the kernel trick can help to alleviate this by calculating the dot product before doing the nonlinear mapping.

Disadvantages​

• not perform very well when the data set has more noise
• where the number of features for each data point exceeds the number of training data samples, the SVM will underperform.

Applications​

• Image classification
• Handwriting recognition
• Bioinformatics
• Text classification
• Top 10 SVM Applications

Vocabulary & Expressions​

Vocabulary & Expressions​

Knowledge Base​

• TELL, ASKS, TELL
  • TELLs the knowledge base what it preceives
  • ASKs the knowledge base what action it should perform
    • reasoning may be done about the current state of the world
    • about the outcomes of possible action sequences and so on
  • TELLs the knowledge base which action was chosen, and returns the action so that it can be executed
• MAKE-PERCEPT-SENTENCE
  • constructs a sentence asserting that the agent preceived the given percept at the given time.
• MAKE-ACTION-QUERY
  • constructs a sentence that asks what action should be done at the current time.
• MAKE-ACTION-SENTENCE
  • constructs a sentence asserting that the chosen action was executed.

Logical connectives​

BNF (Backus–Naur Form) grammar of sentences Symbols from Logic and Set Theory

• $\neg$ : negation (NOT), $\neg W_{1,3}$
  • A literal is either an atomic sentence (a positive literal) or a negated atomic sentence (a negative literal).
• $\land$ : conjunction (AND), $W_{1,3} \land P_{3, 1}$
  • its parts are the conjuncts.
• $\lor$ : disjunction (OR), $(W_{1,3} \land P_{3,1}) \lor W_{2,2}$
  • its parts are the disjuncts.
• $\implies$ : implication (IMPLIES), $(W_{1,3} \land P_{3,1}) \implies \neg W_{2,2}$
  • its premise or antecedent, and its conclusion or consequent is the part that follows the $\implies$.
  • Implications are also called rules or if-then statements.
  • Sometimes written as $\rightarrow$ or $\supset$.
• $\iff$ : biconditional (IF AND ONLY IF), $W_{1,3} \iff \neg W_{2,2}$

Truth tables​

• Logical equivalence: $P \equiv Q$:
• Validity: a sentence is valid if it is true in all models.
  • Deduction Theorem: For any sentences $\alpha$ and $\beta$, $\alpha \models \beta$ if and only if $(\alpha \implies \beta)$ is valid.
• Satisfiability: a sentence is satisfiable if it is true in, or satisfied by, some model.
• Modus Ponens: $\frac{\alpha \implies \beta, \alpha}{\therefore \beta}$
  • whenever any sentences of the form $\alpha \implies \beta$ and $\alpha$ are given, then the sentence $\beta$ can be inferred.
• And-Elimination: $\frac{\alpha \land \beta}{\therefore \alpha}$
  • from a conjunction, one of the conjuncts can be inferred.
• monotonicity: the set of entailed sentences can only increase as information is added to the knowledge base.
  • inference rules can be applied whenever suitable premises are found in the knowledge base, regardless of what other sentences are present.

NLP​

Tokenization​

The process of dividing a text into a sequence of words.

• Different models uses different tokenization methods.

Corpus​

a large and structured collection of text

• a corpus typically consists of at least a million words of text
• at least tens of thousands of distinct vocabulary words.

Text classification​

• the process of categorizing text into organized groups.
• text classifiers can automatically analyze text and then assign a set of predefined tags or categories based on its content.
• machine learning approach
  • Features
    • BoW
    • TF-IDF
  • Features + classifier
    • Logistic regression
    • SVM
    • Naive Bayes
• Deep learning approach
  • Neural models: CNNs (capture local n-grams)
  • RNNs, LSTMs (sequence-aware)
  • Transformers (e.g. BERT)
    • Contextual embedding
• Modern enhancements
  • Embedding + classifier: Pretrained embeddings (Word2Vec) + classifier
  • Fine-tuned transformers: BERT fine-tuned

Bag of Words, BoW​

• it represents a text as a bag of its words
• we can understand the meaning of a document from its content (words) their multiplicity (frequency, number of occurrences)
• mainly used as a tool of feature extraction.
• limitations
  • ignores syntax and the context
  • disregarding grammar
  • discards word order - words are independent of each other
  • considers only the meanings of the words in the sentence

# examples

Example1 = "He likes to watch movies. Mary likes movies too."
Example2 = "Mary also likes to watch football games."

# Vocabulary
Vocab = {"He", "likes", "to", "watch", "movies", "Mary", "also", "football", "games"}

# BoW representation
BoW1 = {He: 1, likes: 2, to: 1, watch: 1, movies: 2, Mary: 1, also: 0, football: 0, games: 0}
BoW2 = {He: 0, likes: 1, to: 1, watch: 1, movies: 0, Mary: 1, also: 1, football: 1, games: 1}

[[1,2,1,1,2,1,0,0,0], [0,1,1,1,0,1,1,1,1]] 

TF-IDF​

Term Frequency - Inverse Document Frequency

• Model based on the statistics of word counts.
• idea is that key terms and important ideas are likely to repeat.
• includes a scoring function that measure the relevance of a document to a query.
  • the function takes a document with a corpus and a query as input and returns a numeric score.
  • the doucments that have the highest scores are considered as the most relevant documents.
• Term Frequency
  • $TF(q_i, d_j, D)$
• Inverse Document Frequency
  • $IDF(q_i, D) = \log\frac{N}{DF(q_i, D)}$
    • $DF(q_i, D)$: number of documents in the corpus $D$ that contain the term $q_i$
• $N = |D|$: total number of documents in the corpus $D$
• TF-IDF score
  • $TFIDF(q_i, d_j, D) = TF(q_i, d_j) \cdot IDF(q_i, D)$

Examples of TF-IDF​

• Document 1: "John likes to watch movies."
• Document 2: "Mary likes movies too."
• Document 3: "John also likes football."

Naive Bayes​

• naive refers to a very strong simplifying assumption about the features
• Conditional independence assumption
  • Given class $Y$, all the features $X = {X_1, X_2, ..., X_n}$ are assumed mutually independent.
• $P(X | Y) = P(X_1, ..., X_n | Y) = \prod_{i=1}^{n} P(X_i | Y)$
• Bayes rule
  • $P(Y | X) = \frac{P(X | Y) P(Y)}{P(X)} \propto P(Y) P(X | Y)$
  • $P(Y | X_1, ..., X_n) \propto P(Y) \prod_{i=1}^{n} P(X_i | Y)$
• Sentiment Analysis
  • $p(C_k | x_1, ..., x_n) = \frac{1}{Z} p(C_k) \prod_{i=1}^{n} p(x_i | C_k)$
    • $Z = p(x) = \sum_{k} p(C_k) p(x | C_k)$
      • scaling factor for normalization of $p(C_k | x)$
  • maximum a posteriori (MAP) decision rule
    • $\hat{y} = \argmax\limits_{k \in 1, ..., K}p(C_k) \prod_{i=1}^{n} p(x_i | C_k)$

Examples of Naive Bayes​

$P(Class | w_{1:N}) = \alpha \cdot P(Class) \cdot \prod_{j} P(w_j | Class)$

• Analyze the sentiment
  • my grandson loved it
  • $x_1 = \text{my}$, $x_2 = \text{grandson}$, $x_3 = \text{loved}$, $x_4 = \text{it}$
  • $C = {positive, negative}$
  • $\hat{y} = \argmax\limits_{k \in \{positive, negative\}} p(C_k) \cdot p(x_1 | C_k) \cdot p(x_2 | C_k) \cdot p(x_3 | C_k) \cdot p(x_4 | C_k)$
    • positive case
      • $p(positive) = 0.49$
      • $p(my | positive) = 0.30$
      • $p(grandson | positive) = 0.01$
      • $p(loved | positive) = 0.32$
      • $p(it | positive) = 0.30$
      • $p(positive | x) \propto p(positive) \cdot p(my | positive) \cdot p(grandson | positive) \cdot p(loved | positive) \cdot p(it | positive) = 0.49 \times 0.30 \times 0.01 \times 0.32 \times 0.30 = 0.00014256$
    • nagative case
      • $p(negative) = 0.51$
      • $p(my | negative) = 0.20$
      • $p(grandson | negative) = 0.02$
      • $p(loved | negative) = 0.08$
      • $p(it | negative) = 0.4$
      • $p(negative | x) \propto p(negative) \cdot p(my | negative) \cdot p(grandson | negative) \cdot p(loved | negative) \cdot p(it | negative) = 0.51 \times 0.20 \times 0.02 \times 0.08 \times 0.4 = 0.00006528$
    • $Z = p(x) = \sum_{k} p(C_k) p(x | C_k)$
      • $= p(positive) \cdot p(my, grandson, loved, it | positive) + p(negative) \cdot p(my, grandson, loved, it | negative)$
      • $= 0.00014256 + 0.00006528 = 0.00020784$
      • the probability of $x$, obtained by adding up its probabilities under each class.
    • $p(positive | x) = \frac{p(positive) \cdot p(my, grandson, loved, it | positive)}{Z} = \frac{0.00014256}{0.00020784} \approx 0.6867$
    • $p(negative | x) = \frac{p(negative) \cdot p(my, grandson, loved, it | negative)}{Z} = \frac{0.00006528}{0.00020784} \approx 0.3133$
  • Decision
    • $\hat{y} = \argmax\limits_{k \in \{positive, negative\}} \{k = positive : 0.6867, k = negative : 0.3133\}$
    • The sentiment is positive.
• Spam detection
  • Probabilities learned from data:
    • $P(\text{Spam}) = 0.4$, $P(\text{Ham}) = 0.6$
    • $P(\text{free}|\text{Spam}) = 0.8$, $P(\text{free}|\text{Ham}) = 0.1$
    • $P(\text{win}|\text{Spam}) = 0.7$, $P(\text{win}|\text{Ham}) = 0.05$
  • New document: "free win"
    • Spam score: $0.4 \times 0.8 \times 0.7 = 0.224$
    • Ham score: $0.6 \times 0.1 \times 0.05 = 0.003$
      → Classified as Spam.