To get you started with Matplotlib for visualizing cognitive modeling and neural

networks, let's go through the basics, gradually working up to applications

relevant to cognitive science and neural networks.

1. Introduction to Matplotlib
Matplotlib is a powerful Python library used for creating static, animated, and
interactive visualizations. The pyplot module in Matplotlib provides a simple
interface for creating plots, much like the plotting features in MATLAB.
Here's a quick start to see how it works:
import matplotlib.pyplot as plt

# Sample data
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]

# Basic line plot

plt.plot(x, y)
plt.xlabel("Input")
plt.ylabel("Output")
plt.title("Basic Line Plot")
plt.show()
This basic code creates a line plot, labeling the x- and y-axes and adding a title.

2. Plotting Neural Network Training Metrics

When training neural networks (or models that resemble neural network pro-
cesses), tracking metrics like loss and accuracy is essential. Here’s an example
using Matplotlib to plot these metrics over training epochs.
import matplotlib.pyplot as plt

# Simulated data
epochs = list(range(1, 11))
train_loss = [0.9, 0.8, 0.6, 0.5, 0.4, 0.35, 0.3, 0.25, 0.2,
0.15]
val_loss = [1.0, 0.9, 0.75, 0.65, 0.6, 0.55, 0.5, 0.45, 0.4,
0.35]

# Plotting
plt.plot(epochs, train_loss, label="Training Loss")
plt.plot(epochs, val_loss, label="Validation Loss", linestyle='--')
plt.xlabel("Epochs")
plt.ylabel("Loss")

1
plt.title("Loss Over Epochs")
plt.legend()
plt.show()
This plot shows how the loss changes over epochs, helping you understand if
your model is learning well.

3. Visualizing Neural Network Layers and Outputs

You can also use Matplotlib to visualize the outputs of each layer in a neural
network. This is useful for interpreting what the network is "seeing" at different
stages.
For example, let's say you have a single hidden layer with 10 neurons. You could
visualize the activation values (outputs) of each neuron:
import numpy as np

# Simulated activation data

neurons = np.arange(1, 11)
activations = np.random.random(10)

# Bar plot of activations

plt.bar(neurons, activations)
plt.xlabel("Neuron")
plt.ylabel("Activation")
plt.title("Hidden Layer Activations")
plt.show()
This gives you a sense of how active each neuron is for a given input, useful in
understanding neural network behavior during cognitive modeling.

4. Heatmaps for Cognitive Modeling and Neural Network Weight

Visualization
In cognitive modeling, heatmaps are helpful to visualize patterns or activation
maps. They’re also commonly used to plot neural network weights.
import numpy as np

# Simulated weight matrix

weights = np.random.random((10, 10))

# Heatmap of weights
plt.imshow(weights, cmap='viridis')
plt.colorbar()

2
plt.title("Neural Network Weights Heatmap")
plt.show()
The color intensity in a heatmap can represent different values (e.g., connection
strengths in neural networks), making it a handy visualization for complex,
interconnected data.

5. Plotting Activation Functions and Loss Landscapes

In cognitive modeling, activation functions (like ReLU, Sigmoid, Tanh) are
essential for determining how neurons respond to inputs. Here’s an example of
visualizing activation functions:
import numpy as np

x = np.linspace(-10, 10, 100)

# Activation functions
relu = np.maximum(0, x)
sigmoid = 1 / (1 + np.exp(-x))
tanh = np.tanh(x)

# Plotting
plt.plot(x, relu, label="ReLU")
plt.plot(x, sigmoid, label="Sigmoid")
plt.plot(x, tanh, label="Tanh")
plt.xlabel("Input")
plt.ylabel("Activation")
plt.title("Activation Functions")
plt.legend()
plt.show()
Visualizing these functions helps in understanding their behavior, especially
when comparing different types of neurons in a network.

6. Tips for Using Matplotlib Effectively

• Annotations: Use plt.annotate() to add explanations to specific data
points.
• Subplots: Use plt.subplot() to create multiple plots in a single figure.
• Colors and Styles: Choose different color, linestyle, and marker
options to differentiate lines and improve readability.
• Interactivity: Use Jupyter notebooks for real-time adjustments to plots
if you're working in a Jupyter environment.

3
By following these steps, you’ll have a solid foundation for using Matplotlib to
visualize cognitive processes, neural networks, and more complex data associated
with cognitive modeling. Let me know if you'd like further explanations on any
specific technique or example!
In the context of training neural networks or other machine learning models,
train_loss and val_loss are metrics that measure how well the model is
performing on two different datasets: the training set and the validation set.
Here’s a detailed breakdown of each:

1. Train Loss (Training Loss)

• Definition: The train loss measures the model's error on the training
dataset—the data it has directly learned from.
• Calculation: It’s typically calculated after each epoch, which is one
complete pass through the training dataset. The model makes predictions
on the training data, and then a loss function (like Mean Squared Error,
Cross-Entropy, etc.) computes the difference between predicted values and
the actual values.
• Purpose: The train loss shows how well the model is learning from the
training data. If the train loss decreases over time, it means the model is
fitting the training data better.

2. Val Loss (Validation Loss)

• Definition: The validation loss measures the model's error on the
validation dataset, which consists of data the model hasn’t seen during
training.
• Calculation: It’s computed by making predictions on the validation data
and calculating the error with the same loss function used for training loss.
The model’s parameters are not updated during this step.
• Purpose: Validation loss helps you evaluate how well the model generalizes
to new, unseen data. It’s a good indicator of model generalization, which
is the model’s ability to perform well on data outside of its training set.

Why Both Are Important

• Monitoring Overfitting: If the train loss decreases steadily, but the
validation loss stops decreasing (or starts increasing), this may indicate
overfitting. Overfitting happens when the model learns the training data
too well, including noise or irrelevant details, making it perform worse on
new data.
• Optimizing Model Performance: If both train and validation losses
decrease, it generally means the model is learning effectively. You aim for

4
 a balance where both losses decrease without the validation loss starting
to increase (which would mean overfitting).

Example Scenario
Imagine you’re training a neural network for image classification, and your loss
values over time look like this:

Epoch Train Loss Validation Loss

1 0.90 0.95
5 0.40 0.50
10 0.20 0.35
15 0.10 0.50

In this example:
• From epochs 1 to 10, both train loss and validation loss are decreasing,
which is good.
• After epoch 10, train loss continues to decrease, but validation loss increases.
This indicates that the model might be overfitting and suggests you might
need to apply regularization techniques (like dropout) or stop training at
an earlier epoch.
Interpreting a heatmap of the weights in a neural network can give insights into
how the network is processing information, and potentially where adjustments
might improve performance. Here’s a step-by-step guide on how to interpret it:

1. Understanding the Axes and Color Scale

• Rows and Columns: The rows usually represent neurons from one layer,
and the columns represent neurons from the next layer. For instance, in a
weight matrix between Layer 1 (10 neurons) and Layer 2 (5 neurons), there
would be a 10x5 matrix where each entry represents the weight between
specific neurons in these layers.
• Color Scale: Each color represents the magnitude of a weight value, where
usually:
– Darker or cooler colors (e.g., deep blue) represent smaller or negative
weights.
– Brighter or warmer colors (e.g., yellow, red) represent larger or positive
weights.
• Zero or Neutral Value: If the color scale includes zero, this often shows
as a middle or neutral color (e.g., green on a blue-to-red scale).

2. Identifying Patterns in Weights

• High or Low Values: Large positive or negative weights mean those
connections are strong and highly influential for the network’s output,

5
 either reinforcing or inhibiting signals.
• Symmetry: Patterns like symmetry in weights may sometimes indicate
redundancy, which might need pruning. Symmetry in specific layers (like
convolutional layers) can also indicate similar feature detections happening
across different neurons.
• Uniformity or Sparsity:
– If weights are more uniform, with few distinct values, the layer might
not be learning meaningful patterns or is initialized poorly.
– If weights are sparse (e.g., a lot of zero or low-value weights), it
can indicate that the network is efficiently learning to ignore certain
connections, especially in techniques like L1 regularization.

3. Detecting Potential Issues

• Overfitting: If most weights in a particular layer show high values, it
could indicate that the layer is memorizing the training data, which is
common in overfitting. Reducing this through regularization (e.g., dropout)
can help.
• Dead Neurons: If an entire row or column shows weights close to zero, the
neuron represented by that row or column may be inactive or “dead.” Dead
neurons do not contribute meaningfully to learning, and can sometimes
indicate issues, especially if prevalent across layers.

4. Comparing Weight Layers

Comparing heatmaps across different layers can show how each layer transforms
input information:
• Early Layers: These often show more general patterns (e.g., detecting
edges or simple shapes in image data).
• Deeper Layers: In cognitive and neural network modeling, deeper layers
often show more abstract, complex patterns, which would reflect in less
regularity or more scattered weight values in the heatmap.

Example Interpretation
Imagine a heatmap with a 5x5 weight matrix where darker squares represent
negative weights, lighter squares represent positive weights, and mid-tone squares
represent weights close to zero:
• A row with all light squares suggests a neuron with highly positive connec-
tions, influencing the next layer positively.
• A column with mostly dark or neutral squares indicates that this neuron
in the next layer receives lower or inhibitory input, likely making it less
active.
This approach can make it easier to decide on adjustments, whether that means
regularizing, pruning, or retraining layers for better network performance.

6
Subplots in Matplotlib allow you to display multiple plots within the same
figure. This can be especially useful for comparing different types of data side-by-
side, like the training and validation losses over epochs or visualizing activation
functions together.
Here's a basic guide to creating subplots.

1. Simple Subplots Using plt.subplot()

The plt.subplot() function lets you create multiple subplots in a single figure
by specifying the number of rows and columns.

Example: Two Line Plots in a 1x2 Layout import matplotlib.pyplot

as plt
import numpy as np

# Sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x) # Sine wave
y2 = np.cos(x) # Cosine wave

# Create a figure
plt.figure(figsize=(10, 4))

# First subplot
plt.subplot(1, 2, 1) # 1 row, 2 columns, plot 1
plt.plot(x, y1, label="Sine")
plt.title("Sine Wave")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.legend()

# Second subplot
plt.subplot(1, 2, 2) # 1 row, 2 columns, plot 2
plt.plot(x, y2, color="orange", label="Cosine")
plt.title("Cosine Wave")
plt.xlabel("x")
plt.ylabel("cos(x)")
plt.legend()

# Show the figure

plt.tight_layout() # Adjust layout to prevent overlap
plt.show()
In this example:
• The subplot(1, 2, 1) specifies a grid of 1 row and 2 columns, and the 1

7
 means "first plot."
• The subplot(1, 2, 2) specifies the second plot in the same row.
• plt.tight_layout() ensures the plots don’t overlap.

2. Using plt.subplots() for More Flexibility

Using plt.subplots() is generally more powerful. It creates an array of axes
objects, which gives you better control over each subplot.

Example: 2x2 Grid of Subplots # Create a 2x2 grid of subplots

fig, axs = plt.subplots(2, 2, figsize=(10, 8))

# Plot in each subplot

x = np.linspace(0, 10, 100)

# First plot - sine wave

axs[0, 0].plot(x, np.sin(x))
axs[0, 0].set_title("Sine Wave")

# Second plot - cosine wave

axs[0, 1].plot(x, np.cos(x), color="orange")
axs[0, 1].set_title("Cosine Wave")

# Third plot - sine squared

axs[1, 0].plot(x, np.sin(x)**2, color="green")
axs[1, 0].set_title("Sine Squared")

# Fourth plot - cosine squared

axs[1, 1].plot(x, np.cos(x)**2, color="red")
axs[1, 1].set_title("Cosine Squared")

# Add space between subplots

fig.tight_layout()

plt.show()
Here’s how it works:
• fig, axs = plt.subplots(2, 2) creates a 2x2 grid of subplots.
• axs[0, 0] accesses the first subplot, axs[0, 1] the second, and so on.
• Each subplot can have its own settings, labels, and titles.

8
3. Combining Different Types of Plots
You can use subplots to combine different types of plots for a better overview,
such as line plots, bar plots, and heatmaps.

Example: Line Plot and Heatmap in a 1x2 Layout import numpy as

np

# Sample data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create figure with subplots

fig, axs = plt.subplots(1, 2, figsize=(12, 5))

# Line plot on the first subplot

axs[0].plot(x, y, label="Sine Wave")
axs[0].set_title("Line Plot")
axs[0].set_xlabel("x")
axs[0].set_ylabel("sin(x)")
axs[0].legend()

# Heatmap on the second subplot

data = np.random.rand(10, 10)
heatmap = axs[1].imshow(data, cmap='viridis')
axs[1].set_title("Random Data Heatmap")
fig.colorbar(heatmap, ax=axs[1], orientation="vertical")

# Show the plots

plt.tight_layout()
plt.show()
In this example:
• The left subplot is a line plot, and the right subplot is a heatmap.
• fig.colorbar(heatmap, ax=axs[1]) adds a color bar to the heatmap
for scale interpretation.

This should give you flexibility for laying out multiple plots, helping you compare
and contrast data in cognitive modeling or neural network visualizations! Let
me know if you'd like further help with this.
The linspace function in NumPy generates an array of evenly spaced numbers
over a specified range. It’s particularly useful in plotting and mathematical
computations when you need a sequence of values within a range.

9
Syntax
np.linspace(start, stop, num=50, endpoint=True, retstep=False,
dtype=None)

Parameters
• start: The beginning value of the sequence.
• stop: The end value of the sequence.
• num: The number of samples to generate (default is 50).
• endpoint: If True (default), stop is the last value in the sequence. If
False, the sequence goes up to but does not include stop.
• retstep: If True, returns a tuple of (array, step), where step is the spacing
between samples.
• dtype: The data type of the output array.

Example
import numpy as np

# Generate 10 values between 0 and 1

x = np.linspace(0, 1, 10)
print(x)
This would produce:
[0. 0.11111111 0.22222222 0.33333333 0.44444444
0.55555556 0.66666667 0.77777778 0.88888889 1. ]
In this example, np.linspace(0, 1, 10) generates 10 values between 0 and
1, evenly spaced. It’s commonly used in plotting to create smooth curves by
generating the x values needed for functions like sine, cosine, etc., as shown in
our previous examples.

10