python matlibplot绘制矩阵_matplotlib.pyplot.matshow 矩阵可视化实例

好的，下面是一个简单的 Python 代码，使用 matplotlib.pyplot.matshow 函数实现矩阵可视化：

import numpy as np
import matplotlib.pyplot as plt

# 生成一个 5x5 的随机矩阵
matrix = np.random.rand(5, 5)

# 使用 matshow 函数进行可视化
plt.matshow(matrix)
plt.colorbar()
plt.show()

这个代码会生成一个 5x5 的随机矩阵，并使用 matshow 函数进行可视化。matshow 函数会将矩阵中的每个值映射为一个颜色，从而实现矩阵的可视化。颜色的映射可以通过 colormap 参数进行自定义。

在这个例子中，我们还使用了 colorbar 函数来添加一个颜色条，以便更好地理解矩阵中每个值所对应的颜色。最后，我们使用 show 函数显示可视化结果。

希望这个例子能够帮助你理解如何使用 matshow 函数进行矩阵可视化。

相关问题

#https://pysource.com/2021/10/29/kalman-filter-predict-the-trajectory-of-an-object/ import cv2 import numpy as np import matplotlib.pyplot as plt class KalmanFilter: #实例属性 kf = cv2.KalmanFilter(4, 2) #其值为4，因为状态转移矩阵transitionMatrix有4个维度 #需要观测的维度为2 kf.measurementMatrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0]], np.float32) #创建测量矩阵 kf.transitionMatrix = np.array([[1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 0.7, 0], [0, 0, 0, 0.7]], np.float32) #创建状态转移矩阵 # 创建一个0-99的一维矩阵 z = [i for i in range(100)] z_watch = np.mat(z) # 创建一个方差为1的高斯噪声，精确到小数点后两位 noise = np.round(np.random.normal(0, 1, 100), 2) noise_mat = np.mat(noise) # 将z的观测值和噪声相加 z_mat = z_watch + noise_mat # 定义x的初始状态，即位置和速度 x_mat = np.mat([[0, ], [0, ]]) y_mat = np.mat([[0, ], [0, ]]) def predict(self, coordX, coordY): #实例方法，自己实现一个predict ''' This function estimates the position of the object''' measured = np.array([[np.float32(coordX)], [np.float32(coordY)]]) self.kf.correct(measured) #结合观测值更新状态值，correct为卡尔曼滤波器自带函数 predicted = self.kf.predict() #调用卡尔曼滤波器自带的预测函数 x, y = int(predicted[0]), int(predicted[1]) #得到预测后的坐标值 # 绘制结果 plt.plot(measured[0], 'k+', label='Measured_x') plt.plot(x, 'b-', label='Kalman Filter_x') #plt.plot(real_state, 'g-', label='Real state') plt.legend(loc='upper left') plt.title('Kalman Filter Results') plt.xlabel('Time (s)') plt.ylabel('Position (m)') plt.show() return x, y predict(self,x_mat,y_mat)优化这段python代码，随机生成x和y并实现对x和y的输入值的预测，并画出图像，实现可视化

# 导入必要的库
import cv2
import numpy as np
import matplotlib.pyplot as plt

class KalmanFilter:
def __init__(self):
# 创建卡尔曼滤波器
self.kf = cv2.KalmanFilter(4, 2)
# 创建测量矩阵
self.kf.measurementMatrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0]], np.float32)
# 创建状态转移矩阵
self.kf.transitionMatrix = np.array([[1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 0.7, 0], [0, 0, 0, 0.7]], np.float32)
# 创建过程噪声协方差矩阵
self.kf.processNoiseCov = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0.5, 0], [0, 0, 0, 0.5]], np.float32)
# 定义x的初始状态，即位置和速度
self.x = np.array([[0], [0], [0], [0]], np.float32)

def predict(self, coordX, coordY):
# 将输入值转换为测量值
measured = np.array([[np.float32(coordX)], [np.float32(coordY)]])
# 预测下一时刻的状态值
self.x = self.kf.predict()
# 结合观测值更新状态值
self.x = self.kf.correct(measured)
# 得到预测后的坐标值
x, y = int(self.x[0]), int(self.x[1])
return x, y

# 创建KalmanFilter实例
kf = KalmanFilter()

# 随机生成x和y
x = np.array([i for i in range(1, 101)])
y = np.array([i for i in range(1, 101)])
# 添加随机噪声
x = x + np.random.normal(0, 10, 100)
y = y + np.random.normal(0, 10, 100)

# 预测输入值的位置
predicted_x = []
predicted_y = []
for i in range(100):
px, py = kf.predict(x[i], y[i])
predicted_x.append(px)
predicted_y.append(py)

# 绘制结果
plt.plot(x, y, 'k+', label='Measured')
plt.plot(predicted_x, predicted_y, 'b-', label='Kalman Filter')
plt.legend(loc='upper left')
plt.title('Kalman Filter Results')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

基于pytorch实现自定义图像数据集分类并绘制混淆矩阵、可视化散点图、损失曲线准确率曲线等代码实现

好的，以下是一个基于PyTorch实现自定义图像数据集分类并绘制混淆矩阵、可视化散点图、损失曲线准确率曲线等的代码实现。请注意，这是一个基本的代码框架，您可能需要根据您的具体需求进行修改和完善。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from sklearn.metrics import confusion_matrix
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import numpy as np

# 定义超参数
num_epochs = 10
batch_size = 32
learning_rate = 0.001

# 定义数据预处理
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载数据集
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 8 * 8, 512)
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(nn.functional.relu(self.conv1(x)))
        x = self.pool(nn.functional.relu(self.conv2(x)))
        x = x.view(-1, 64 * 8 * 8)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 实例化模型和优化器
model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)

# 训练模型
train_loss = []
train_acc = []

for epoch in range(num_epochs):
    running_loss = 0.0
    running_corrects = 0
    for i, (inputs, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        _, preds = torch.max(outputs, 1)
        running_loss += loss.item() * inputs.size(0)
        running_corrects += torch.sum(preds == labels.data)

    epoch_loss = running_loss / len(train_dataset)
    epoch_acc = running_corrects.double() / len(train_dataset)
    train_loss.append(epoch_loss)
    train_acc.append(epoch_acc)

    print('Epoch [{}/{}], Loss: {:.4f}, Accuracy: {:.4f}'.format(epoch+1, num_epochs, epoch_loss, epoch_acc))

# 测试模型并绘制混淆矩阵
model.eval()
y_true = []
y_pred = []

with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, preds = torch.max(outputs, 1)
        y_true += labels.numpy().tolist()
        y_pred += preds.numpy().tolist()

confusion = confusion_matrix(y_true, y_pred)
plt.imshow(confusion, cmap='binary')
plt.show()

# 可视化散点图
model.eval()
features = []
labels = []

with torch.no_grad():
    for i, (inputs, labels_batch) in enumerate(test_loader):
        outputs = model(inputs)
        features_batch = outputs.numpy()
        features.append(features_batch)
        labels.append(labels_batch.numpy())

features = np.concatenate(features, axis=0)
labels = np.concatenate(labels, axis=0)

tsne = TSNE(n_components=2, random_state=0)
embeddings = tsne.fit_transform(features)

fig, ax = plt.subplots()
scatter = ax.scatter(embeddings[:,0], embeddings[:,1], c=labels)
legend = ax.legend(*scatter.legend_elements(), loc="upper right", title="Classes")
ax.add_artist(legend)
plt.show()

# 绘制损失曲线和准确率曲线
fig, ax = plt.subplots()
ax.plot(train_loss, label='train loss')
ax.plot(train_acc, label='train accuracy')
ax.set_xlabel('Epoch')
ax.legend()
plt.show()

希望这可以帮助您实现自定义图像数据集分类并绘制混淆矩阵、可视化散点图、损失曲线准确率曲线等。