NNDL 作业5：卷积

最新推荐文章于 2024-11-14 13:48:50 发布
最新推荐文章于 2024-11-14 13:48:50 发布
阅读量238 收藏
点赞数 2
文章标签： python 深度学习 numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51668257/article/details/127341550
版权

NNDL 作业5：卷积

作业1

编程实现：

在这里插入图片描述
在这里插入图片描述

1.在这里插入图片描述

2.在这里插入图片描述

import numpy as np
import torch
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

w1 = np.array([1, -1], dtype='float32').reshape([1, 1, 1, 2])
w2 = np.array([1, -1], dtype='float32').T.reshape([1, 1, 2, 1])
print(w2)
w1 = torch.Tensor(w1)
w2 = torch.Tensor(w2)
conv1 = torch.nn.Conv2d(1, 1, [1, 2])
conv1.weight = torch.nn.Parameter(w1)

conv2 = torch.nn.Conv2d(1, 1, [2, 1])
conv2.weight = torch.nn.Parameter(w2)# 创建图像
img = np.ones([7, 6], dtype='float32')
img[:, 3:] = 0.
img[:, :3] = 255.
x = img.reshape([1, 1, 7, 6])
x = torch.Tensor(x)

y1 = conv1(x).detach().numpy()
y2 = conv2(x).detach().numpy()
plt.subplot(131).set_title('图1')
plt.imshow(img,cmap='gray')
plt.subplot(132).set_title('图1使用卷积核为(1,-1)结果')
plt.imshow(y1.squeeze(),cmap='gray')
plt.subplot(133).set_title('图1使用卷积核为(1,-1)T结果')
plt.imshow(y2.squeeze(),cmap='gray')
plt.show()

这里是引用

  1. 在这里插入图片描述

  2. 在这里插入图片描述

import numpy as np
import torch
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

w1 = np.array([1, -1], dtype='float32').reshape([1, 1, 1, 2])
w2 = np.array([1, -1], dtype='float32').T.reshape([1, 1, 2, 1])
print(w2)
w1 = torch.Tensor(w1)
w2 = torch.Tensor(w2)
conv1 = torch.nn.Conv2d(1, 1, [1, 2])
conv1.weight = torch.nn.Parameter(w1)

conv2 = torch.nn.Conv2d(1, 1, [2, 1])
conv2.weight = torch.nn.Parameter(w2)# 创建图像
img = np.ones([8, 8], dtype='float32')
img[:4, :4] = 0.
img[:4, 4:] = 255.
img[4:, :4] = 255.
img[4:, 4:] = 0.

x = img.reshape([1, 1, 8, 8])
x = torch.Tensor(x)

y1 = conv1(x).detach().numpy()
y2 = conv2(x).detach().numpy()
plt.subplot(131).set_title('图2')
plt.imshow(img, cmap='gray')
plt.subplot(132).set_title('图2使用卷积核为(1,-1)结果')
plt.imshow(y1.squeeze(), cmap='gray')
plt.subplot(133).set_title('图2使用卷积核为(1,-1)T结果')
plt.imshow(y2.squeeze(), cmap='gray')
plt.show()

这里是引用

5.在这里插入图片描述

import numpy as np
import torch
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

w1 = np.array([1, -1], dtype='float32').reshape([1, 1, 1, 2])
w2 = np.array([1, -1], dtype='float32').T.reshape([1, 1, 2, 1])
w3 =  np.array([[1,-1,-1,1]],dtype='float32').reshape([1,1,2,2])

print(w3)
w1 = torch.Tensor(w1)
w2 = torch.Tensor(w2)
w3 = torch.Tensor(w3)

conv1 = torch.nn.Conv2d(1, 1, [1, 2])
conv1.weight = torch.nn.Parameter(w1)

conv2 = torch.nn.Conv2d(1, 1, [2, 1])
conv2.weight = torch.nn.Parameter(w2)

conv3 = torch.nn.Conv2d(1,1,[2,2])
conv3.weight = torch.nn.Parameter(w3)
# 创建图像
img = np.ones([9, 9], dtype='float32')
for i in range(7):
    img[i+1,i+1]=255.
    img[i+1,7-i]=255.

x = img.reshape([1, 1, 9, 9])
x = torch.Tensor(x)

y1 = conv1(x).detach().numpy()
y2 = conv2(x).detach().numpy()
y3 = conv3(x).detach().numpy()
plt.subplot(221).set_title('图3')
plt.imshow(img, cmap='gray')
plt.subplot(222).set_title('图3使用卷积核为(1,-1)结果')
plt.imshow(y1.squeeze(),cmap='gray')
plt.subplot(223).set_title('图3使用卷积核为(1,-1)T结果')
plt.imshow(y2.squeeze(),cmap='gray')
plt.subplot(224).set_title('图3使用卷积核为[[1 -1],[-1 1]]结果')
plt.imshow(y3.squeeze(),cmap='gray')
plt.show()

这里是引用

作业2

一、概念

卷积：卷积是指在滑动中提取特征的过程，可以形象地理解为用放大镜把每步都放大并且拍下来，再把拍下来的图片拼接成一个新的大图片的过程。
卷积核：可以看作对某个局部的加权求和；它是对应局部感知，它的原理是在观察某个物体时我们既不能观察每个像素也不能一次观察整体，而是先从局部开始认识，这就对应了卷积。卷积核的大小一般为奇数*奇数
特征图：特征图就是对原始图像像素矩阵经过卷积操作后的结果矩阵。
特征选择：卷积的作用就是用来提取特征，具体提取哪部分特征需要选择。类似于放大镜去选择放大哪一部分。
步长：卷积核进行一次卷积后，横向移动的步长和纵向移动的步长。
填充：边缘上的像素永远不会位于卷积核中心，而卷积核也没法扩展到边缘区域以外,所以输入图像的边缘被“修剪”掉了。这是不理想的，通常我们都希望输入和输出的大小应该保持一致。将输入图像的边缘用0填充。
感受野：最后特征图的某个点对应原图的范围。

二、探究不同卷积核的作用

1、锐化：

这里是引用

2.边缘检测：

这里是引用

3、模糊：

在这里插入图片描述

4、底部轮廓检测:

这里是引用

5、左侧轮廓检测:

这里是引用

6、右侧轮廓检测：

这里是引用

7.上部轮廓检测：

这里是引用

8.浮雕：

这里是引用

三、编程实现

1、实现灰度图的边缘检测、锐化、模糊。（必做）

边缘检测：

#边缘检测
import numpy as np
import torch
from torch import nn
from torch.autograd import Variable
from PIL import Image
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号 #有中文出现的情况，需要u'内容
# https://blog.csdn.net/weixin_40123108/article/details/83510592
file_path = 'D:\\copy\\6.jpg'
im = Image.open(file_path).convert('L')  # 读入一张灰度图的图片
im = np.array(im, dtype='float32')  # 将其转换为一个矩阵
print(im.shape[0], im.shape[1])
plt.imshow(im.astype('uint8'), cmap='gray')  # 可视化图片
plt.title('原图')
plt.show()

im = torch.from_numpy(im.reshape((1, 1, im.shape[0], im.shape[1])))
conv1 = nn.Conv2d(1, 1, 3, bias=False,padding=5)  # 定义卷积

sobel_kernel = np.array([[-1, -1, -1],
                         [-1, 8, -1],
                         [-1, -1, -1]], dtype='float32')  # 定义轮廓检测算子
print(sobel_kernel.shape)
sobel_kernel = sobel_kernel.reshape((1, 1, 3, 3))  # 适配卷积的输入输出
conv1.weight.data = torch.from_numpy(sobel_kernel)  # 给卷积的 kernel 赋值

edge1 = conv1(Variable(im))  # 作用在图片上

x = edge1.data.squeeze().numpy()
print(x.shape)  # 输出大小

plt.imshow(x, cmap='gray')
plt.show()

在这里插入图片描述

在这里插入图片描述

锐化：

#锐化
#encoding:utf-8
#By:Eastmount CSDN 2021-07-19
import cv2
import numpy as np
import matplotlib.pyplot as plt

#读取图像
img = cv2.imread('D:\\copy\\6.jpg')
lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#高斯滤波
gaussianBlur = cv2.GaussianBlur(grayImage, (3,3), 0)

#阈值处理
ret, binary = cv2.threshold(gaussianBlur, 127, 255, cv2.THRESH_BINARY)

#Roberts算子
kernelx = np.array([[-1,0],[0,1]], dtype=int)
kernely = np.array([[0,-1],[1,0]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#Prewitt算子
kernelx = np.array([[1,1,1],[0,0,0],[-1,-1,-1]], dtype=int)
kernely = np.array([[-1,0,1],[-1,0,1],[-1,0,1]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Prewitt = cv2.addWeighted(absX,0.5,absY,0.5,0)

#Sobel算子
x = cv2.Sobel(binary, cv2.CV_16S, 1, 0)
y = cv2.Sobel(binary, cv2.CV_16S, 0, 1)
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#拉普拉斯算法
dst = cv2.Laplacian(binary, cv2.CV_16S, ksize = 3)
Laplacian = cv2.convertScaleAbs(dst)

#效果图
titles = ['Source Image', 'Binary Image', 'Roberts Image',
          'Prewitt Image','Sobel Image', 'Laplacian Image']
images = [lenna_img, binary, Roberts, Prewitt, Sobel, Laplacian]
for i in np.arange(6):
    plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')
    plt.title(titles[i])
    plt.xticks([]),plt.yticks([])
plt.show()

这里是引用

模糊：
(1)均值模糊：

# 图像模糊处理
# 均值模糊 box blur

import cv2
import numpy as np
import matplotlib.pyplot as plt

if __name__ == "__main__":
    image = cv2.imread('D:\\copy\\6.jpg')

    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    # 此为均值模糊
    # （30,1）为一维卷积核，指在x，y方向偏移多少位
    dst1 = cv2.blur(image, (30, 1))

    # 此为中值模糊，常用于去除椒盐噪声
    dst2 = cv2.medianBlur(image, 15)

    # 自定义卷积核，执行模糊操作，也可定义执行锐化操作
    kernel = np.ones([5, 5], np.float32) / 25
    dst3 = cv2.filter2D(image, -1, kernel=kernel)

    plt.subplot(2, 2, 1)
    plt.imshow(image)
    plt.axis('off')
    plt.title('Offical')

    plt.subplot(2, 2, 2)
    plt.imshow(dst1)
    plt.axis('off')
    plt.title('Box blur')

    plt.subplot(2, 2, 3)
    plt.imshow(dst2)
    plt.axis('off')
    plt.title('median blur')

    plt.subplot(2, 2, 4)
    plt.imshow(dst3)
    plt.axis('off')
    plt.title('defined blur')

    plt.show()

这里是引用

(2)高斯模糊：

# 图像模糊处理
# 高斯模糊 gaussian blur
# 使用自编写高斯噪声及自编写高斯模糊函数与自带高斯函数作效果对比

import cv2
import numpy as np
import matplotlib.pyplot as plt


def clamp(pv):
    if pv > 255:
        return 255
    if pv < 0:
        return 0
    else:
        return pv


def gaussian_noise(image):        # 加高斯噪声
    h, w, c = image.shape
    for row in range(h):
        for col in range(w):
            s = np.random.normal(0, 20, 3)
            b = image[row, col, 0]   # blue
            g = image[row, col, 1]   # green
            r = image[row, col, 2]   # red
            image[row, col, 0] = clamp(b + s[0])
            image[row, col, 1] = clamp(g + s[1])
            image[row, col, 2] = clamp(r + s[2])
    dst = cv2.GaussianBlur(image, (15, 15), 0)  # 高斯模糊
    return dst, image


if __name__ == "__main__":
    src = cv2.imread('D:\\copy\\6.jpg')
    plt.subplot(2, 2, 1)
    plt.imshow(src)
    plt.axis('off')
    plt.title('Offical')

    output, noise = gaussian_noise(src)
    cvdst = cv2.GaussianBlur(src, (15, 15), 0)   # 高斯模糊

    plt.subplot(2, 2, 2)
    plt.imshow(noise)
    plt.axis('off')
    plt.title('Gaussian Noise')

    plt.subplot(2, 2, 3)
    plt.imshow(output)
    plt.axis('off')
    plt.title('Gaussian Blur')

    plt.subplot(2, 2, 4)
    plt.imshow(cvdst)
    plt.axis('off')
    plt.title('defined blur by opencv')

    plt.show()

在这里插入图片描述

(3)运动模糊：

# 图像模糊处理
# 运动模糊，亦称动态模糊，motion blur
# 运动模糊：由于相机和物体之间的相对运动造成的模糊

import numpy as np
import cv2
import matplotlib.pyplot as plt


def motion_blur(image, degree=12, angle=45):

    image = np.array(image)
    # 这里生成任意角度的运动模糊kernel的矩阵， degree越大，模糊程度越高
    M = cv2.getRotationMatrix2D((degree / 2, degree / 2), angle, 1)
    motion_blur_kernel = np.diag(np.ones(degree))
    motion_blur_kernel = cv2.warpAffine(motion_blur_kernel, M, (degree, degree))
    motion_blur_kernel = motion_blur_kernel / degree
    blurred = cv2.filter2D(image, -1, motion_blur_kernel)
    # convert to uint8
    cv2.normalize(blurred, blurred, 0, 255, cv2.NORM_MINMAX)
    blurred = np.array(blurred, dtype=np.uint8)
    return blurred


if __name__ == "__main__":

    img = cv2.imread('D:\\copy\\6.jpg')
    dst = motion_blur(img)

    plt.subplot(1, 2, 1)
    plt.imshow(img)
    plt.axis('off')
    plt.title('Offical')

    plt.subplot(1, 2, 2)
    plt.imshow(dst)
    plt.axis('off')
    plt.title('Motion blur')

    plt.show()

这里是引用

2、调整卷积核参数，测试并总结。（必做）

调整卷积核步长为2：
在这里插入图片描述


在这里插入图片描述

调整卷积核步长为3：
在这里插入图片描述


在这里插入图片描述

结果：随着步长变大，像素点逐渐减少，并且图像提取的边界越来越模糊。因此，选择一个合适的步长十分重要。

调整卷积核参数，设置padding为3：

这里是引用
在这里插入图片描述

调整卷积核参数，设置padding为5：

这里是引用
在这里插入图片描述

Padding，它会用额外的“假”像素填充边缘（值一般为0），这样，当卷积核扫描输入数据时，它能延伸到边缘以外的伪像素，从而使输出和输入大小相同。因此使用padding可以使图片的边缘也可以得到使用，不被浪费掉。

3、使用不同尺寸图片，测试并总结。（必做）

原图：

在这里插入图片描述

边缘检测:

在这里插入图片描述

锐化：

这里是引用

模糊：
（1）均值模糊：

这里是引用

(2)高斯模糊:

这里是引用

（3）运动模糊：

这里是引用

4.探索更多类型卷积核。（选做）

上图已经进行多种类型卷积核的操作，见上图。

5.尝试彩色图片边缘检测。（选做）

import numpy as np
import torch
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
from PIL import Image
import matplotlib.pyplot as plt

im = Image.open(r'D:\\copy\\8.jpg').convert('L') # 读入一张灰度图的图片
im = np.array(im, dtype='float32') # 将其转换为一个矩阵

#print(im.shape[0],im.shape[1])     448*448
# 可视化图片
plt.imshow(im.astype('uint8'), cmap='gray')
im = torch.from_numpy(im.reshape((1, 1, im.shape[0], im.shape[1])))
conv1 = nn.Conv2d(in_channels=1,out_channels=1, kernel_size=3, bias=False,stride=1,padding=1) # 定义卷积

sobel_kernel = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], dtype='float32') # 定义轮廓检测算子
sobel_kernel = sobel_kernel.reshape((1, 1, 3, 3)) # 适配卷积的输入输出
conv1.weight.data = torch.from_numpy(sobel_kernel) # 给卷积的 kernel 赋值

edge1 = conv1(Variable(im)) # 作用在图片上
edge1 = edge1.data.squeeze().numpy() # 将输出转换为图片的格式
plt.imshow(edge1, cmap='gray')

plt.show()

这里是引用

这里是引用

总结

本次作业主要实现了卷积的应用，更加深刻的了解了卷积等一系列的概念，以及如何实现图像的边缘检测和锐化和模糊。调整卷积核参数，可以通过改变卷积核的步长，改变padding等主要是对cov2d函数进行改变使图片发生变化。
卷积能够提取特征的原理：特征是数字图像映射到计算机处理的矩阵，而每个矩阵的数值就是一个特征点，由一幅图像组成的整个特征矩阵就是一个特征图，每输入网络的点针对神经网络而言都是一个特征，不同维度的特征就是不同维度的特征向量。故卷积、CNN并不是完全说是提取特征，而是对特征的一种处理或者说是转变，所以卷积和卷积神经网络不过是针对图像方面的特征，处理起来更符合能达到预期结果。
参考：
概念01 为什么卷积、CNN能够提取特征？什么是特征、卷积？
图像中的卷积为何能够提取特征
深度学习之卷积

Perfect(*^ω^*)
关注
深度学习-神经网络卷积核理解
Tc、zyh的博客
10-24 1万+
文章目录一、前言二、降维/升维增加非线性跨通道信息交互三、 应用实例四、卷积计算为什么卷积核都是奇数呢？ 一、前言 卷积核（convolutional kernel）：可以看作对某个局部的加权求和；它是对应局部感知，它的原理是在观察某个物体时我们既不能观察每个像素也不能一次观察整体，而是先从局部开始认识，这就对应了卷积。卷积核的大小一般有1x1,3x3和5x5的尺寸（一般是奇数x奇数）。 卷积核的个数就对应输出的通道数（channels），这里需要说明的是对于输入的每个通道，输出每个通道上的卷积核是不一
数字图像处理第五章——图像复原与重建
fjyalzl的博客
07-14 4421
图像复原技术的主要目的是以预先确定的目标来改善图像，大部分是一个客观的过程。图像复原试图利用退化现象的某种先验知识来复原被退化的图像。因而，复原技术是面向退化模型的，并且采用相反的过程进行处理，以便恢复出原图像。如下图所示，退化过程被建模为一个退化函数和一个加性噪声项，对一幅输入图像f(x,y)进行处理，产生一幅退化后的图像g(x,y)。如果H是一个线性的、位置不变的过程，那么空间域中的退化图像可由下式给出：等价的频率域表示：数字图像中，噪声主要来源于图像的获取和/或传输过程。频率特性：傅里叶域中噪声的频率
NNDL 作业7：第五章课后题
m0_73478739的博客
10-30 649
NNDL 作业7：第五章课后题
NNDL 作业7：第五章课后题（1×1 卷积核 | CNN BP）
Guo_weiqi的博客
10-30 171
NNDL 作业7：第五章课后题（1×1 卷积核 | CNN BP）
ks8 本地化部署 F5-TTS
陈锐的技术笔记
11-13 550
此外，F5-TTS 还创新性地引入了推理时的 Sway Sampling 策略，这一策略可以在推理阶段优先处理早期的流步骤，从而提高生成语音与输入文本的对齐效果。在 LibriSpeech-PC 数据集上，该模型的字错误率（WER）达到了2.42，并且在推理时的实时因子(RTF)为0.15，显著优于之前的扩散模型 E2TTS，后者在处理速度和鲁棒性上存在短板。传统的 TTS 模型往往需要进行复杂的持续时间建模、音素对齐和专门的文本编码，这些都增加了合成过程的复杂性。继续TSS的启动，进入pod 输入命令。
外星人入侵
weixin_60243362的博客
11-12 1641
外星人入侵项目实践
什么是Python模块化编程
大数据实战派
11-13 322
模块化编程是一种编程方法论，它将程序的功能划分为多个独立的模块，每个模块负责程序中的一部分功能。通过这种方式，程序的代码被分割成更小、更易管理的部分，每个模块都可以独立开发、调试和测试，模块之间通过接口进行交互。模块化编程是将一个复杂的程序拆分为多个独立、功能明确的小模块的编程方法。这不仅提高了代码的复用性和可维护性，还促进了团队协作开发，增强了程序的扩展性。在实际开发中，模块化编程让代码结构更加清晰，逻辑更加简洁，为程序的长久维护和扩展打下了坚实的基础。
conda创建 、查看、 激活、删除 python 虚拟环境
最新发布
DATABALL 的博客
11-14 113
conda创建 、查看、 激活、删除python虚拟环境
使用`nohup`后台运行Python服务不输出日志避坑
A15216110998的专栏
11-14 114
这里的应替换为你的Python脚本名称。错误日志未输出这里使用了2>&1来将错误输出重定向到与标准输出相同的文件。代码中的print()语句未输出到日志有时候，由于Python的缓冲输出机制，print()到屏幕的内容可能不会立即显示在日志中。要解决这个问题，可以使用-u现在，print()语句应该会立即出现在日志文件中。其他注意事项如果你的脚本依赖于环境变量，确保在启动脚本之前已经设置了这些变量，或者在脚本中显式导入它们。考虑使用第三方库如logging。
pytorch基础-数据集导入
gudao07的博客
11-14 537
pytorch的数据导入，包括dataset,tensorboard,transform,dataloder等
【python基础算法编程】
weixin_42333261的博客
11-12 493
这个函数使用两个指针，一个从字符串的开头开始，另一个从字符串的结尾开始。否则，函数递归调用自身，传入去掉首尾字符的子字符串。递归是一种直接的方法来计算斐波那契数列，但对于较大的 N 值，它会非常慢，因为它会重复计算相同的子问题。然后，它比较字符串的第一个和最后一个字符是否相等。如果它们不相等，函数返回。函数是一个生成器函数，用于生成从给定序列中选择指定长度的元素的所有排列。可以使用循环从最后一个元素开始，逐个访问每个元素，直到第一个元素。斐波那契数列是一个经典的数学序列，其中每个数字都是前两个数字的和。
11.11 case class
2402_87076449的博客
11-11 236
1，使用case class创建图书信息类Book：包含四个属性：ID，书名，作者，价格，数量。2，创建一个名为BookList的可变List，它只能用来保存Book的实例。3，初始化三本不同的书（注意id不同就是不同的书），加入到BookList中。7，删除指定ID的书。9，遍历图书列表，并打印每本书的详细信息。3.自动重写：toString，equals，hashCode，copy。3.自动重写：toString，equals，hashCode，copy。1.不可变性 创建的对象的属性是不能修改的。
大模型落地之ollama控制设备
weixin_44772948的博客
11-10 110
本地环境：ollama3.2（理论上ollama3.1以上就支持tool功能，但是笔者没有试过）(PS:不足点，在输入不是控制指令的相关问题时，大概率也会调用工具，需要后续调优）
sklearn.datasets中make_classification函数
u013172930的博客
11-13 306
make_classification 是 sklearn.datasets 模块中的一个函数，用于生成一个用于分类任务的虚拟数据集。它允许你生成具有指定特征、类别和噪声等属性的人工数据集，通常用于测试和演示机器学习算法。通过from sklearn.datasets import make_classification导入。
逐行加载 HTML 内容并实时显示效果：使用 wxPython 的实现
Winfredzhang的博客
11-10 663
self.lines = [] # 用于存储HTML文件的行内容self.line_index = 0 # 当前行的索引self.timer = wx.Timer(self) # 创建定时器self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer) # 绑定定时器事件定义self.lines用于存储 HTML 文件的行，表示当前行索引，self.timer为定时器，用于逐行加载 HTML 内容。事件绑定到OnTimer方法。本文演示了如何使用wxPython。
【优雅的在Java程序中判空和Null】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
11-10 140
在Entity中添加。
模型转换best.pt转onnx,运行export.py修改文件
weixin_52448289的博客
11-11 191
结果运行export.py发生报错 修改export.py这部分代码。模型转换时将上述部分改为。将上述代码将进行修改。
2、编程练习：利用卷积神经网络，处理MNIST 数据集分类问题。 https://github.com/nndl/exercise/
05-04
好的，以下是处理 MNIST 数据集分类问题的卷积神经网络的代码： ```python import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # 加载 MNIST 数据集 mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # 定义输入和输出的占位符 x = tf.placeholder(tf.float32, [None, 784]) y_true = tf.placeholder(tf.float32, [None, 10]) # 将输入数据转换为图片的形式 x_image = tf.reshape(x, [-1, 28, 28, 1]) # 第一层卷积 conv1 = tf.layers.conv2d(inputs=x_image, filters=32, kernel_size=[5, 5], padding="same", activation=tf.nn.relu) # 第一层池化 pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2) # 第二层卷积 conv2 = tf.layers.conv2d(inputs=pool1, filters=64, kernel_size=[5, 5], padding="same", activation=tf.nn.relu) # 第二层池化 pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2) # 将图像数据展开为一维向量 pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64]) # 第一层全连接层 fc1 = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu) # Dropout keep_prob = tf.placeholder(tf.float32) fc1_drop = tf.nn.dropout(fc1, keep_prob) # 第二层全连接层 y_pred = tf.layers.dense(inputs=fc1_drop, units=10) # 定义损失函数和优化器 cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=y_true, logits=y_pred)) train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) # 定义准确率 correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y_true, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # 开始训练 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(20000): batch_x, batch_y = mnist.train.next_batch(50) sess.run(train_step, feed_dict={x: batch_x, y_true: batch_y, keep_prob: 0.5}) if i % 100 == 0: train_acc = sess.run(accuracy, feed_dict={x: batch_x, y_true: batch_y, keep_prob: 1.0}) print("Step %d, training accuracy %g" % (i, train_acc)) # 在测试集上计算准确率 test_acc = sess.run(accuracy, feed_dict={x: mnist.test.images, y_true: mnist.test.labels, keep_prob: 1.0}) print("Test accuracy %g" % test_acc) ``` 这个代码使用了两个卷积层和两个全连接层，以及池化和 Dropout。 在训练过程中，我们每 100 次迭代输出一次训练集上的准确率，并在最后输出测试集上的准确率。 你可以将该代码保存到一个 Python 文件中，然后在命令行中运行该文件来执行训练和测试。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值