Back to series
· 14 min read

How does artificial intelligence understand and process information?


Artificial intelligence can understand text, recognize images, analyze speech, and even generate code and video from a description. But from a computer’s perspective, AI does not directly perceive and understand information the way humans do.

What a computer processes is still, at its core, numbers, matrices, vectors, and mathematical operations. So-called “understanding” means that through training on large amounts of data, the model learns statistical patterns, structural relationships, and semantic associations in information, and encodes these patterns into model parameters.

Take large language models as an example. When a user enters:

Please explain what an operating system is.

The model does not simply look up some fixed answer; rather, it needs to complete a series of processing steps:

  1. Convert the input text into tokens that the model can process.
  2. Map the tokens to vector representations.
  3. Extract contextual information through a neural network.
  4. Establish associations between words, concepts, and context.
  5. Calculate the probability distribution of the next token based on the current context.
  6. Gradually generate a response through a decoding strategy.

Understanding this mechanism is the foundation for understanding large language models, computer vision, speech recognition, and multimodal AI.

This article analyzes how artificial intelligence actually processes information from several levels: information representation, feature extraction, semantic modeling, context understanding, and information generation.


I. How Do Computers Represent Information?

Before discussing how AI understands information, we need to clarify a basic question:

Computers themselves do not directly process human language, images, and sound; they process encoded digital information.

Different types of information require different forms of digital representation.

1.1 Text Information

What humans see is text, for example:

Artificial intelligence is changing the way software is developed.

Internally, a computer does not directly store abstract textual meaning; it first converts characters into numbers through character encoding.

Common character encodings include:

  • ASCII: mainly used for English characters and basic symbols.
  • Unicode: assigns unified code points to various languages and symbols around the world.
  • UTF-8: a widely used implementation of Unicode encoding.

For example, the Unicode code point of the character A is U+0041, and its UTF-8 encoding is the byte 0x41.

Note:

Character encoding solves the problem of how characters are represented as bytes; it does not solve the semantic problem of words.

For example:

Apple

A computer can know what these characters are through encoding, but character encoding alone does not tell it whether it refers to a fruit, a brand, or some software project.

1.2 Image Information

Digital images can usually be represented as pixel matrices.

An RGB image with a width of 3 and a height of 2 can be abstracted as:

I \in \mathbb{R}^{2 \times 3 \times 3}

Where:

  • 2: image height.
  • 3: image width.
  • 3: the three RGB color channels.

Each pixel contains three values: red, green, and blue.

For example:

Pixel=(255,0,0)

represents a pure red pixel.

Real images usually have a much larger resolution. For example, a 1920 × 1080 RGB image contains:

1920 \times 1080 \times 3 =6,220,800

color values.

Computer vision models need to extract edges, textures, shapes, objects, and higher-level visual features from these values.

1.3 Audio Information

Digital audio usually converts continuous sound signals into discrete values through sampling.

Assume the sampling rate is 16 kHz, meaning 16,000 audio samples are collected per second.

An audio signal can be represented as:

x=[x_1,x_2,\ldots,x_n]

where each x_i represents the sound amplitude captured at a certain moment.

In addition to the raw waveform, AI may also convert audio into feature representations such as spectrograms or mel spectrograms, so that the model can analyze the frequency structure and temporal changes of sound.

1.4 Digital Representations of Different Information Types

Information Type Original Representation Common AI Processing Form
Text Characters, bytes Tokens, vectors
Image Pixel matrix Image patches, visual feature vectors
Audio Discrete sample sequence Waveform, spectrum, audio tokens
Video Continuous image frames and audio Frame sequence, spatiotemporal features
Structured data Values, fields, records Numerical features, categorical encodings, vectors

From this, we can see that although different types of information have different forms of expression, they can ultimately all be converted into numerical structures that models can process.

flowchart TB
    A["Information in the real world"] --> B["Digitization and encoding"]

    B --> C["Text"]
    B --> D["Images"]
    B --> E["Audio"]
    B --> F["Video"]
    B --> G["Structured data"]

    C --> H["Token sequence"]
    D --> I["Pixel matrix or image patches"]
    E --> J["Waveform or spectrum"]
    F --> K["Video frames and audio sequences"]
    G --> L["Numerical and categorical features"]

    H --> M["Model input representation"]
    I --> M
    J --> M
    K --> M
    L --> M

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F

II. How Does AI Convert Information into Understandable Representations?

Digitization is only the first step.

For AI, knowing which number corresponds to a character, or what color corresponds to a pixel, is not the same as understanding their meaning.

The model needs to further build internal representations that can reflect the features and semantic relationships of information.

This usually involves three important concepts:

  • Tokenization: information segmentation and encoding.
  • Embedding: vector representation.
  • Representation Learning: representation learning.

2.1 Tokenization: Splitting Information into Tokens

Taking large language models as an example, the model usually does not directly input an entire passage of text as an indivisible whole; instead, it first splits the text into Tokens.

A Token can be:

  • A complete word.
  • Part of a word.
  • A Chinese character.
  • A punctuation mark.
  • A special control marker.

For example:

Artificial intelligence changes the world

A certain model might split it into:

["Artificial", "intelligence", "changes", "the", "world"]

This is only an illustration. Different models use different Tokenizers, and the segmentation result for the same text may be completely different.

The main purposes of Tokenization are:

  1. To convert text into discrete symbols in the model's vocabulary.
  2. To control the basic units of model input and output.
  3. To unify different languages and text forms into sequences that the model can process.

Each Token usually corresponds to an integer ID in the vocabulary.

For example:

Token Token ID
Artificial 1024
intelligence 2048
changes 3056
the 4096
world 5120

The above IDs are for illustration only and do not represent the vocabulary of a real model.

After Tokenization, the text can be represented as:

X=[1024,2048,3056,4096,5120]

Here, three concepts need to be distinguished:

Concept Meaning
Character The basic writing unit in human language
Token The discrete symbol unit processed by the model
Token ID The integer index of a Token in the vocabulary

A token is not the same as a word, nor is it the same as a character.

Chinese, English, code, and special symbols may be split in different ways by different tokenizers.

2.2 Embedding: Converting Tokens into Vectors

A token ID is just an integer index.

The model cannot simply understand the semantic relationships between tokens based on the magnitude of the integers.

For example, a word with token ID 100 is not necessarily more important than a word with token ID 200, nor does it imply that some semantic distance exists between the two.

Therefore, the model needs to map discrete token IDs to continuous vectors through Embedding.

Suppose the model's vector dimension is 4:

E(1024)=[0.12,0.35,-0.21,0.48]
E(2048)=[0.18,0.29,-0.16,0.52]

The hidden dimension of a real large language model is usually far larger than 4.

Embedding can be understood as a vector lookup process.

Let:

  • The vocabulary size be V.
  • The embedding dimension be d.
  • The embedding matrix be W_E.

Then:

W_E\in\mathbb{R}^{V\times d}

For token ID i, its vector representation is:

e_i=W_E[i]

In other words, you take out the corresponding row from the embedding matrix.

After this step, discrete tokens have been converted into continuous vectors.

2.3 Why Use Vectors?

Vectors can express features and relationships in a continuous mathematical space.

For example:

cat
dog
car

After training, the model may learn that:

  • Cat and dog are relatively close along certain semantic features.
  • Cat and car may be far apart along these semantic features.
  • Cat has statistical associations with concepts such as animal, pet, and mammal.

The degree of similarity between vectors can be computed using methods such as cosine similarity:

\operatorname{cos}(A,B)= \frac{A\cdot B}{\|A\|\|B\|}

Where:

  • A, B: two vectors.
  • A\cdot B: the vector dot product.
  • \|A\|, \|B\|: the magnitudes of the vectors.

The closer the cosine similarity is to 1, the closer the directions of the two vectors are.

But note:

Embedding vectors do not inherently contain human-defined semantic labels; they are numerical representations learned by the model during training.

The relationships in the vector space are shaped jointly by the training objective, the data distribution, the model architecture, and the parameters.

2.4 Representation Learning

Representation learning is an important concept in machine learning.

It refers to a model automatically learning useful feature representations from data, rather than relying entirely on manually designed features.

In traditional machine learning, developers may need to extract features by hand.

For example, to determine whether an email is spam, one might use:

  • Whether it contains certain keywords.
  • Whether there are a large number of links.
  • Whether the sender is suspicious.
  • Whether the subject line contains marketing terms.

Deep learning, by contrast, can let a neural network automatically learn multi-level feature representations through training.

flowchart TB
    A["Raw Data"] --> B["Initial Feature Representation"]
    B --> C["Low-level Feature Extraction"]
    C --> D["Mid-level Feature Combination"]
    D --> E["High-level Feature Representation"]
    E --> F["Task-relevant Information"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D

Take image recognition as an example:

  • Low-level features: edges, colors, textures.
  • Mid-level features: local shapes, part structures.
  • High-level features: object categories, scene relationships.

Take natural language processing as an example:

  • Low-level features: words, characters, and local patterns.
  • Mid-level features: phrases, syntactic relationships.
  • High-level features: contextual semantics, task-relevant information.

This does not mean that a one-to-one hierarchical structure corresponding to human linguistic concepts necessarily exists inside the model; rather, it is a basic way of thinking about how deep neural networks extract and combine information layer by layer.


3. How Does AI Understand Context and Semantic Relationships?

If the model merely maps each token to a fixed vector, it will still struggle to understand complex language.

Because the same word may carry different meanings in different contexts.

For example:

Apples are delicious.
Apple released a new phone.

The concept that “apple” points to is not the same in these two sentences.

The model needs to draw on context to dynamically adjust its representation of a token.

This is precisely one of the key capabilities of modern large language models.

3.1 Why Is Contextual Information Important?

Natural language is clearly context-dependent.

The meaning of a word is usually shaped by the following factors:

  • The words before and after it.
  • The sentence it appears in.
  • The current paragraph.
  • The conversation history.
  • The current task.
  • Domain knowledge.

For example:

Java is a programming language.
I drank a cup of Java today.

In the second sentence, Java likely involves a coffee-related context rather than a programming language.

If a model makes judgments based on a single word alone, ambiguity arises easily.

Therefore, AI needs to combine information from multiple tokens to build context-dependent representations.

3.2 Attention: The Attention Mechanism

Attention is one of the core mechanisms in the modern Transformer architecture.

It enables the model to dynamically focus on other positions in the sequence, according to what the position currently being processed requires.

For example:

Xiaoming put the book on the table because it was heavy.

The model needs to use context to determine what “it” most likely refers to.

The attention mechanism helps the model build associations between different tokens.

Its core idea is:

Compute a weighted combination of different Values based on how relevant each Query is to each Key.

In a Transformer, the input vectors are passed through three learnable linear transformations to produce:

  • Query (Q): what information the current Token wants to find.
  • Key (K): what matching features the current Token offers.
  • Value (V): the actual information content the current Token provides.

The computation process:

Q=XW_Q
K=XW_K
V=XW_V

Where:

  • X: the input vector matrix.
  • W_Q, W_K, W_V: parameter matrices learned during model training.

The attention weights are computed with the following formula:

Attention(Q,K,V)= softmax\left( \frac{QK^T}{\sqrt{d_k}} \right)V

Where:

  • QK^T: computes the relevance between Query and Key.
  • d_k: the dimensionality of the Key vectors.
  • \sqrt{d_k}: the scaling factor.
  • softmax: converts the relevance scores into normalized weights.
  • V: the information that takes part in the weighted sum.

The final result is a weighted combination of multiple Values, based on the attention weights.

3.3 The Computation Process of the Attention Mechanism

flowchart TB
    A["Input vector X"] --> B["Linear transformation"]
    B --> C["Generate Query"]
    B --> D["Generate Key"]
    B --> E["Generate Value"]

    C --> F["Compute correlation between Q and K"]
    D --> F
    F --> G["Scaling"]
    G --> H["Softmax normalization"]
    H --> I["Obtain attention weights"]
    I --> J["Weighted sum over Value"]
    E --> J
    J --> K["Output context-aware representation"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F

3.4 Self-Attention: Self-Attention Mechanism

Self-Attention means that Query, Key, and Value all come from the same input sequence.

For example:

Artificial intelligence is changing the way software is developed.

Each Token in the sequence can aggregate information from other Tokens according to attention weights.

This means:

  • “Artificial” can attend to “intelligence”.
  • “changing” can attend to “software development”.
  • “way” can attend to the context of the entire sentence.

In actual models, attention relationships are jointly determined by data and parameters; they are not simply fixed associations assigned to each word.

3.5 Multi-Head Attention: Multi-Head Attention Mechanism

A single attention head can compute attention relationships only through one set of projection matrices.

Multi-Head Attention, by contrast, uses multiple attention heads, allowing the model to learn information associations in different representation subspaces.

Its basic form is:

head_i=Attention(Q_i,K_i,V_i)
MultiHead(Q,K,V)= Concat(head_1,\ldots,head_h)W_O

Where:

  • h: number of attention heads.
  • Concat: concatenates the results of multiple attention heads.
  • W_O: output projection matrix.

Multiple attention heads can provide different ways of combining information, but this should not be simplistically understood as each head corresponding to one clear human semantic relationship.

3.6 Positional Encoding: How Does the Model Know the Order of Information?

Attention itself does not inherently understand sequence order.

For example:

The cat chases the dog.
The dog chases the cat.

Without positional information, the model would find it difficult to distinguish these two sentences solely from an unordered set of Tokens.

Therefore, Transformer needs to introduce positional information.

Common methods include:

  • Absolute positional encoding.
  • Relative positional encoding.
  • RoPE (Rotary Position Embedding, rotary positional encoding).
  • ALiBi (Attention with Linear Biases).

Taking RoPE as an example, it applies position-dependent rotational transformations to some dimensions of Query and Key, so that the attention computation can reflect relative positional information.

Positional encoding addresses the question of how sequence order enters the model's computation.

It should be noted that positional encoding is not semantic understanding itself, but an important foundation for the model to understand sequence structure.


IV. How Does AI Learn Knowledge from Information?

The previous section introduced how information is converted into vectors and how the model establishes contextual relationships.

But why can a model understand sentences it has never seen, and even answer questions that have not appeared directly in the training data?

The key lies in training.

Through large amounts of data and optimization algorithms, the model continuously adjusts its internal parameters, gradually learning the statistical patterns and structural relationships in the data.

4.1 Basic Structure of a Neural Network

A deep neural network usually contains:

  • Input layer: receives input information.
  • Hidden layers: extract and combine features.
  • Output layer: produces prediction results.

Take a simple neural network as an example:

h=f(Wx+b)

Where:

  • x: input vector.
  • W: weight matrix.
  • b: bias term.
  • f: activation function.
  • h: output features.

A model is usually composed of a large number of such computational units and parameters.

By combining multiple layers of networks, a model can learn complex nonlinear mappings.

4.2 The Basic Process of Model Training

The core goal of model training is to adjust parameters so that the model's output matches the training objective as closely as possible.

A typical training process includes:

  1. Feed in the training data.
  2. Perform forward propagation to compute the model output.
  3. Compute the loss against the true target.
  4. Perform backpropagation to compute parameter gradients.
  5. The optimizer updates the parameters based on the gradients.
  6. Repeat the training process.
flowchart TB
    A["Prepare training data"] --> B["Input to model"]
    B --> C["Forward propagation"]
    C --> D["Compute model output"]
    D --> E["Compute loss function"]
    E --> F["Backpropagation"]
    F --> G["Compute parameter gradients"]
    G --> H["Optimizer updates parameters"]
    H --> I{"Continue training?"}
    I -->|"Yes"| B
    I -->|"No"| J["Obtain the trained model"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4.3 Loss Function: How Do We Measure How Well a Model Predicts?

The loss function measures the difference between the model's predictions and the training objective.

For example, when training a language model, it usually needs to predict the next Token.

Suppose the true next Token is:

operating system

The model might output:

Candidate Token Model predicted probability
operating system 0.70
database 0.15
compiler 0.10
other 0.05

Generally, the higher the probability assigned to the true Token, the better the model's prediction for the current training objective.

The cross-entropy loss can be expressed as:

L=-\sum_{i=1}^{V}y_i\log(p_i)

Where:

  • V: vocabulary size.
  • y_i: true label distribution.
  • p_i: model predicted probability.

When the true labels use One-Hot encoding, the loss can be simplified to:

L=-\log(p_{\text{true}})

The model needs to be trained to increase the predicted probability of the true Token as much as possible.

4.4 Backpropagation: How Does a Model Adjust Its Parameters?

After the model produces a prediction, it needs to know which parameters caused the current error.

Backpropagation uses the chain rule to compute the gradient of the loss function with respect to each parameter:

\frac{\partial L}{\partial \theta}

Where:

  • L: loss function.
  • \theta: model parameters.

The optimizer then updates the parameters based on the gradients.

Taking the most basic gradient descent as an example:

\theta_{t+1}= \theta_t-\eta\nabla_\theta L

Where:

  • \theta_t: current parameters.
  • \eta: learning rate.
  • \nabla_\theta L: gradient of the loss function with respect to the parameters.

Through repeated iteration, the model gradually learns the patterns in the training data.

4.5 Why Can Large Language Models Learn Language Patterns?

Taking an autoregressive language model as an example, its core training objective is usually to predict the next Token based on the preceding Tokens.

For the sequence:

Artificial intelligence is changing the world

The model may learn the following prediction tasks:

Input: Artificial
Prediction: intelligence

Input: Artificial intelligence
Prediction: is

Input: Artificial intelligence is
Prediction: changing

Input: Artificial intelligence is changing
Prediction: the world

During actual training, multiple prediction positions are usually processed simultaneously through parallel computation, rather than necessarily completing training serially one Token at a time.

The typical objective function of an autoregressive language model is:

L(\theta)= -\sum_{t=1}^{T} \log P_\theta(x_t|x_{<t})

Where:

  • x_t: the Token at the current position.
  • x_{<t}: the Tokens before the current position.
  • P_\theta: the conditional probability distribution determined by the model parameters.

Through large amounts of text, the model learns word collocations, grammatical structures, contextual associations, ways of expressing knowledge, and patterns related to reasoning.

It is particularly important to emphasize:

Predicting the next Token is the training objective; it does not mean that the model can only mechanically predict text.

To improve prediction capability, the model needs to learn multi-level internal representations that can support prediction. These representations may contain information such as semantics, grammar, knowledge associations, and task structure.

However, this learning result is not equivalent to consciousness or subjective understanding in the human sense.


5. How Does AI Process a User Input?

Having understood information representation, attention mechanisms, and model training, we can combine these pieces of knowledge to look at the complete processing of a user input in a large language model.

Suppose the user inputs:

Please explain decorators in Python.

5.1 Input Preprocessing

The system receives the user input and performs necessary processing according to the model interface and task requirements.

This may involve:

  • Text normalization.
  • Message structure parsing.
  • Tokenization.
  • Adding special Tokens.
  • Input length checking.

For dialogue models, the input is usually not just the user's current sentence; it may also include contextual information such as system instructions, historical messages, and tool results.

5.2 Tokenization

The text is converted into a Token sequence.

For example:

["Please", "explain", "decorators", "in", "Python"]

The actual segmentation result depends on the model's Tokenizer.

Afterwards, Tokens are mapped to integer IDs.

5.3 Embedding and Position Processing

The model converts Token IDs into vector representations and introduces position-related information.

At this point, the model input is no longer just a discrete integer sequence, but a matrix containing multiple vectors.

This can be abstractly represented as:

X\in\mathbb{R}^{T\times d}

Where:

  • T: input sequence length.
  • d: model hidden dimension.

5.4 Transformer Network Processing

The vector sequence enters the Transformer network.

A typical Transformer Block usually includes:

  • Multi-head self-attention mechanism.
  • Feed-forward neural network (FFN).
  • Residual connections.
  • Layer Normalization or other normalization structures.

Different models may differ in normalization methods, attention implementations, activation functions, and network architecture.

A simplified Transformer Block can be represented as:

H'=Norm(H+Attention(H))
H_{out}=Norm(H'+FFN(H'))

The formulas here are structural illustrations; actual implementations may also involve details such as positional encoding, attention masks, and gating mechanisms.

5.5 Output Layer and Probability Calculation

After processing through multiple network layers, the model obtains the hidden state at the current prediction position.

Then, through the output projection layer, the hidden state is mapped to the vocabulary dimension:

z=hW_U+b_U

Where:

  • h: final hidden state.
  • W_U: output projection matrix.
  • b_U: bias term.
  • z: Logits, i.e., unnormalized scores.

Then they are converted into a probability distribution through Softmax:

P(x_i)= \frac{e^{z_i}}{\sum_j e^{z_j}}

The model thus obtains the probability distribution of the next Token.

5.6 Decoding and Text Generation

The model selects the next token from the probability distribution according to the decoding strategy.

Common strategies include:

  • Greedy Decoding: select the token with the highest probability.
  • Temperature: adjust the sharpness of the probability distribution.
  • Top-K: sample only from the K candidates with the highest probabilities.
  • Top-P: sample from the candidate set whose cumulative probability reaches the specified threshold.

After generating a token, the model adds it to the context and then continues predicting the next token.

This process continues until the stopping condition is reached.

flowchart TB
    A["User Input"] --> B["Input Preprocessing"]
    B --> C["Tokenization"]
    C --> D["Token ID Sequence"]
    D --> E["Embedding and Position Processing"]
    E --> F["Transformer Network"]

    F --> G["Output Hidden States"]
    G --> H["Output Projection Layer"]
    H --> I["Logits"]
    I --> J["Softmax Probability Distribution"]
    J --> K["Decoding and Token Selection"]
    K --> L{"End Generation?"}

    L -->|"No"| M["Add New Token to Context"]
    M --> F
    L -->|"Yes"| N["Generate Final Text"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style M fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style N fill:#DCEFE5,stroke:#4F8B70,color:#24563F