python plt画黑白图

你可以使用Matplotlib库中的plt.imshow()函数来画黑白图。首先，将图片转换成灰度图像，然后使用imshow()函数显示灰度图像。

下面是一个简单的示例代码：

import matplotlib.pyplot as plt
import matplotlib.image as mpimg

# 读取图片
img = mpimg.imread('image.png')

# 将图片转换成灰度图像
gray_img = img.mean(axis=2)

# 使用imshow()函数显示灰度图像
plt.imshow(gray_img, cmap='gray')

# 关闭坐标轴
plt.axis('off')

# 显示图像
plt.show()

相关问题

python画黑白饼图

在Python中，可以使用matplotlib库来画黑白饼图。首先，你需要导入matplotlib.pyplot模块。然后，使用plt.pie()函数来绘制饼图。在函数中，你需要传入饼图的数据和标签。数据可以是一个列表，标签可以是一个字符串列表。接下来，你可以使用plt.show()函数来显示饼图。下面是一个示例代码：

import matplotlib.pyplot as plt

# 饼图的数据
data = \[30, 40, 20, 10\]

# 饼图的标签
labels = \['A', 'B', 'C', 'D'\]

# 绘制饼图
plt.pie(data, labels=labels)

# 显示饼图
plt.show()

这段代码会绘制一个简单的黑白饼图，其中data列表中的数值表示每个扇区的大小，labels列表中的字符串表示每个扇区的标签。你可以根据自己的需求修改数据和标签。
#### 引用[.reference_title]
- *1* *2* [python画像素图](https://blog.csdn.net/weixin_39693662/article/details/110376092)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item]
- *3* [Python——教你画朵太阳花](https://blog.csdn.net/weixin_39604092/article/details/110979504)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]

python将黑白图片彩色化

黑白图片彩色化是一项非常有趣的任务，最近使用深度学习技术实现此任务的研究成果也受到了广泛关注。在Python中，你可以使用深度学习框架如TensorFlow或PyTorch来实现此任务。

以下是使用PyTorch实现黑白图片彩色化的基本步骤：

1. 导入必要的库

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10
from tqdm import tqdm

2. 定义模型

定义一个简单的卷积神经网络模型，例如：

class ColorizationNet(nn.Module):
    def __init__(self):
        super(ColorizationNet, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=8, kernel_size=3, stride=2, padding=1)
        self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, stride=2, padding=1)
        self.conv3 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=2, padding=1)
        self.conv4 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding=1)
        self.conv5 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding=1)
        self.conv6 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=2, padding=1)
        self.conv7 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=2, padding=1)
        self.conv8 = nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=2, padding=1)
        self.conv9 = nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=2, padding=1)

        self.deconv1 = nn.ConvTranspose2d(in_channels=512, out_channels=512, kernel_size=4, stride=2, padding=1)
        self.deconv2 = nn.ConvTranspose2d(in_channels=512, out_channels=512, kernel_size=4, stride=2, padding=1)
        self.deconv3 = nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=4, stride=2, padding=1)
        self.deconv4 = nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=4, stride=2, padding=1)
        self.deconv5 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=4, stride=2, padding=1)
        self.deconv6 = nn.ConvTranspose2d(in_channels=64, out_channels=32, kernel_size=4, stride=2, padding=1)
        self.deconv7 = nn.ConvTranspose2d(in_channels=32, out_channels=16, kernel_size=4, stride=2, padding=1)
        self.deconv8 = nn.ConvTranspose2d(in_channels=16, out_channels=2, kernel_size=4, stride=2, padding=1)

        self.relu = nn.ReLU()
        self.tanh = nn.Tanh()

    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.relu(self.conv2(x))
        x = self.relu(self.conv3(x))
        x = self.relu(self.conv4(x))
        x = self.relu(self.conv5(x))
        x = self.relu(self.conv6(x))
        x = self.relu(self.conv7(x))
        x = self.relu(self.conv8(x))
        x = self.relu(self.conv9(x))

        x = self.relu(self.deconv1(x))
        x = self.relu(self.deconv2(x))
        x = self.relu(self.deconv3(x))
        x = self.relu(self.deconv4(x))
        x = self.relu(self.deconv5(x))
        x = self.relu(self.deconv6(x))
        x = self.relu(self.deconv7(x))
        x = self.tanh(self.deconv8(x))

        return x

3. 定义损失函数和优化器

criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

4. 加载数据

使用CIFAR10数据集作为示例数据集，其中包含了50,000张训练集和10,000张测试集的彩色图片，每张图片的大小为32x32像素。

# 数据预处理
transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.Grayscale(num_output_channels=1),
    transforms.ToTensor()
])

train_set = CIFAR10(root='./data', train=True, transform=transform, download=True)
test_set = CIFAR10(root='./data', train=False, transform=transform, download=True)

train_loader = DataLoader(train_set, batch_size=64, shuffle=True)
test_loader = DataLoader(test_set, batch_size=64, shuffle=False)

5. 训练模型

# 训练
for epoch in range(100):
    running_loss = 0.0
    for i, data in tqdm(enumerate(train_loader, 0)):
        inputs, _ = data
        optimizer.zero_grad()

        # 转换为黑白图片
        gray_inputs = inputs[:, 0, :, :].unsqueeze(1)

        # 前向传播
        outputs = model(gray_inputs)

        # 计算损失
        loss = criterion(outputs, inputs)

        # 反向传播和优化
        loss.backward()
        optimizer.step()

        # 统计损失
        running_loss += loss.item()

    # 打印每个epoch的损失
    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(train_loader)}')

6. 测试模型

# 测试
with torch.no_grad():
    model.eval()
    test_loss = 0.0
    for i, data in tqdm(enumerate(test_loader, 0)):
        inputs, _ = data

        # 转换为黑白图片
        gray_inputs = inputs[:, 0, :, :].unsqueeze(1)

        # 前向传播
        outputs = model(gray_inputs)

        # 计算损失
        loss = criterion(outputs, inputs)

        # 统计损失
        test_loss += loss.item()

        # 保存一些样本
        if i == 0:
            inputs = inputs.numpy()
            outputs = outputs.numpy()
            for j in range(8):
                img_in = inputs[j, 0, :, :]
                img_out = outputs[j, :, :, :]
                img_out = np.transpose(img_out, (1, 2, 0))
                plt.subplot(2, 8, j + 1)
                plt.imshow(img_in, cmap='gray')
                plt.subplot(2, 8, j + 9)
                plt.imshow(img_out)

    # 打印测试集上的平均损失
    print(f'Test Loss: {test_loss / len(test_loader)}')

通过以上步骤，你就可以在Python中使用PyTorch实现黑白图片彩色化。