python matlibplot绘制矩阵_matplotlib.pyplot.matshow 矩阵可视化实例
时间: 2023-10-25 13:34:21 浏览: 40
好的,这是一个使用 matplotlib.pyplot.matshow 函数绘制矩阵的示例:
```python
import numpy as np
import matplotlib.pyplot as plt
# 创建一个 5x5 的随机矩阵
matrix = np.random.rand(5, 5)
# 使用 matshow 函数绘制矩阵
plt.matshow(matrix)
# 显示图像
plt.show()
```
这段代码会生成一个随机矩阵,并使用 matshow 函数将其可视化。你可以将这段代码复制到 Python 环境中并运行,观察生成的矩阵图像。
相关问题
#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实现自定义图像数据集分类并绘制混淆矩阵、可视化散点图、损失曲线准确率曲线等的代码实现。请注意,这是一个基本的代码框架,您可能需要根据您的具体需求进行修改和完善。
```python
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()
```
希望这可以帮助您实现自定义图像数据集分类并绘制混淆矩阵、可视化散点图、损失曲线准确率曲线等。