zjh12312311的博客

pytorch 报一下错误：RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.cuda.FloatTensor [1024, 512, 3, 3]], which is output 26 of BroadcastBackward, is at version 2; expected version 1 instead. Hi

β分布Pr(λ)=Γ[α+β]Γ[α]Γ[β]λα−1(1−λ)β−1 Pr(\lambda) = \frac{\Gamma[\alpha+\beta]}{\Gamma[\alpha]\Gamma[\beta]}\lambda^{\alpha-1}(1-\lambda)^{\beta-1}Pr(λ)=Γ[α]Γ[β]Γ[α+β]​λα−1(1−λ)β−1α>0,β>0,0<=λ<=1 \alpha > 0, \beta > 0, 0 <= \lambda &lt

接触AI也挺久了，一会儿来个最大熵模型，一会儿来个交叉熵损失函数，一会儿来个DL

模型压缩，因为巨大的模型能够学习到某个函数，但是用的参数量远远大于了任务所需要的参数量。所以可以降低模型的规模。如采用dropout，模型蒸馏。

数组的属性import numpy as npa = np.arange(24).reshape(2,3,4)b = np.arange(24).reshape(3,8)print(a)print(b)[[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]][[ 0 1 2 3 4 5 6 7] [ 8 9 10 11 12 13

分割数组import numpy as npa = np.arange(24).reshape(2,3,4)b = np.arange(24).reshape(3,8)print(a)print(b)[[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]][[ 0 1 2 3 4 5 6 7] [ 8 9 10 11 12 13 1

数组的组合import numpy as npa = np.arange(6).reshape(2,3)b = a * 2print(a)print(b)[[0 1 2] [3 4 5]][[ 0 2 4] [ 6 8 10]]水平组合使用hstack, 注意传入的是（a,b）print(np.hstack((a,b)))[[ 0 1 2 0 2 4] [ 3 4 5 6 8 10]]使用concatenateprint(np.con

改变数组的维度import numpy as npa = np.arange(24).reshape(2,3,4)print(a)[[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]]ravel flatten函数完成展平的操作flatten函数会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图（view）两种写法print(np

多维数组的切片和索引import numpy as npb = np.arange(24)print(b)[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]reshape函数切分的思想，先分两半，对应2，再在每个分3份对应3……a = b.reshape(2,3,4)print(a)[[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [

在\begin{figure}下面加一行\xdef\xfigwd{\textwidth}即\begin{figure}[htbp] \xdef\xfigwd{\textwidth} \centering \subfigure{ \begin{minipage}[b]{.4\linewidth} \centering \includegraphics[width=3.4cm,height=3cm]{fig20_1.png} \end{minipage} } \su

抱着科研的理想辞职读研，入学近三个月。其他的都好，唯独上某些所谓“必修课”，还有做作业的事情真的让自己很烦。 在这里写出来，不是去抨击教育，只是自己发发牢骚，或许多年之后回过头来再看，还会想吐槽自己身在福中不知福。首先，并不是讨厌上课，相反，工作的时候非常怀念上课的时光，目前也有去旁听自己喜欢课。但是，学校的必修课，不修完必修就无法毕业，但这其中的一些课，根本不是我想学，或者需要的，更别提还有各种作业。都是研究生了，也在自己想做的领域做研究，不排斥学一些其他方面的知识，...

python 动态规划 钢条切割# 钢条长度length = [0,1,2,3,4,5,6,7,8,9,10]# 对应长度的钢条价值value = [0,1,5,8,9,10,17,17,20,9,10]# 求长度为n的钢条，怎么切可以有最大价值def cutting(length, value, n): s = [0]*(n+1) # 小段长度 v = [0]*(n+1) # 价值 if n > len(length): l = len(leng

边缘检测一般的方法，可以先得到灰度图，然后使用高斯模糊GaussianBlur，再用拉普拉斯函数Laplacian做边缘函数就好这里使用更简单的方法，用Canny做:Canny其实用了五个步骤， 高斯lü’bo（用来去噪），计算梯度，边缘上使用非最大抑制NMS，在检测到的边缘上使用双阈值去除假阳性，分析所有边缘和其连接保留真正的边缘import numpy as npimport matplotlib.pyplot as pltimport cv2img = cv2.imread('1.jpg

均值滤波这种滤波方法就是取一个像素的邻域内各像素的平均值作为滤波结果import cv2import matplotlib.pyplot as pltimg = cv2.imread('1.jpg')plt.imshow(img)<matplotlib.image.AxesImage at 0x21b6dbb1518>img_mean = cv2.blur(img, (11,11))plt.imshow(img_mean)<matplotlib.image.Ax

计数排序对每个元素确定小于该元素的个数def countSort(A, k): #k是元素数值上界 c = [0] * k result = [0] * len(A) for i in range(len(A)): c[A[i]] = c[A[i]] + 1 # 计算小于该元素的个数 for i in range((k-1)): c[i+1] = c[i+1] + c[i] # 每个减轻去1是因为索引是从0开始，而计数是从1

卷积核可视化意思核feature map可视化是一样的把卷积核的权重变成图像输出来#卷积核可视化def show_kernal(model): # 可视化卷积核 for name, param in model.named_parameters(): if 'conv' in name and 'weight' in name: in_channels = param.size()[1] out_channels =

因为要对网络里的layer操作，所以网络层命名发生了一些改变LeNet5.pyimport torch.nn as nnimport numpy as npimport torchfrom collections import OrderedDict#定义lenet5class LeNet5(nn.Module): def __init__(self, num_clases=10): super(LeNet5, self).__init__()

一、安装pytorch，安装tensorboardX使用pycharm的seting安装就好二、搭建一个简单的网络这里用LeNet5与tensorboardX相关的语句都标记了出来，主要是传个每轮的loss，参数model自带import torch.nn as nnimport numpy as npimport torch#定义lenet5class LeNet5(nn.Module): def __init__(self, num_clases=10):

一、问题：[layer1_1[[[ 52.373936 16.00824 62.745567 ... 12.321167 2.960958 11.374744 ][ 16.00824 50.275608 28.002008 ... 6.575324 3.6270523 12.703771 ][ 62.745567 28.002008 157.73836 ... 7.091863 10.858132 27.182278 ...

样条插值的思想做回归一、生成数据多项式y=0.2x3+0.5x2−0.8x+3y = 0.2x^3+0.5x^2-0.8x+3y=0.2x3+0.5x2−0.8x+3再加上服从正态分布的噪声 ξ\xiξimport numpyimport matplotlib.pyplot as pltnumpy.random.seed(1)def cal_poly(x): return 0.2 * x ** 3 + 0.5 * x**2 - 0.8 * x + 3#生成100个数据x_da

transpose是转置transformation是变换，如线性变换linear transformation，镜像变换mirror transformation

用10阶多项式拟合10000个点import matplotlib.pyplot as pltimport random一、数据生成#首先保证这10000个点x各不相同，从0-20000内随机生成不同的数,除以100，将x值变为0-200num = random.sample(range(1,20000),10000)num_x = []for i in range(10000): num_x.append(num[i] / 100) #y也一样,y的生成不需要不一样nu

Freezing one weight cause the same result with unfreezing（Deep learning书的一个练习）在神经网络训啦中，冻结某权重，总的误差依然会降为0的现象。# 用灯的组合与能否通信数据来做import numpy as npimport matplotlib.pyplot as pltstreetlights = np.array([ [1,0,1], [0,1,1], [0,0,1], [1,1,1],

图1.邻接矩阵class GraphTable: def __init__(self, mat, unconn=0): # unconn表示选择有无权重 vnum = len(mat) for x in mat: if len(x) != vnum: #检查是否时方阵 print('No square matrix') return self._mat = [m

图像增广import torchimport matplotlib.pyplot as pltfrom torch.utils.data import Dataset, DataLoaderimport torchvisionfrom PIL import Image# 获取图像img = Image.open(r'D:\pyPro\hhandwritten_web\static\images\bg.jpg')plt.imshow(img)<PIL.JpegImagePlugin

import numpy as npimport torchimport mathimport sysimport matplotlib.pyplot as plt一维梯度下降小学习率def gd(eta): times = 10 x = 10 #从5开始梯度下降 results = [x] for i in range(times): x -= eta * 2 * x # x^2的导数 results.append(x)

迷宫问题求解#构造迷宫import numpy as npmap = [ [0,1,0,0,0,0], [0,1,1,1,0,0], [0,1,0,1,1,0], [1,1,0,0,1,0], [0,0,0,0,0,0], [0,0,0,0,0,0]]start = [0,0]end = [5,5]print(map)[[0, 1, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0], [0, 1, 0, 1, 1, 0], [1

假设检验一、单个正态总体均值检验工厂原来的产品重量服从正态分布，均值为5，改进技术后，抽取了20件产品质量，检验均值是否没有改变。原假设均值没变，备择假设均值改变import matplotlib.pyplot as pltimport numpy as np#生成改变后的数据x = [i for i in range(1,21)]weight = np.random.randn(1,20)+5weight = weight[0]print(x)print(weight)[1,

区间估计import matplotlib.pyplot as pltimport numpy as np#随机生成产品质量,正态分布x_data = [i for i in range(1,11)]x_index = np.arange(5) #柱的索引weight = np.random.randn(1,10)+5print(x_data)weight = weight[0]print(weight)[1, 2, 3, 4, 5, 6, 7, 8, 9, 10][5.049

三个常用函数之 compilecomplie是将正则表达式转换为模式对象，这样可以更有效率匹配。使用compile转换一次之后，以后每次使用模式时就不用进行转换pattern：写正则表达式flag ：匹配模式从complie[]函数的定义中，可以看出返回的是一个匹配对象，它单独使用没有意义，要与findadd，search，match搭配使用import rea = '0321-123123'b = re.compile(r'[0-9]*-[0-9]*')r = re.findall(

三个常用函数之一 sub替换字符串，第一个参数是被替换什么，第二个参数是要替换成什么，第三个参数是字符串, 第四个参数是替换次数import rea = 'asdwqe13daasd'r1 = re.sub('asd','123',a,1)r2 = re.sub('asd','123',a)print(r1)print(r2)123wqe13daasd123wqe13da123第二个参数可以是函数,形参.group可以获取到分段截取的字符串def func(a):

三个常用函数之一 findall第一个参数为正则表达式，第二个参数为字符串,返回的是列表，第三个参数是匹配模式，常用的有：re.I 忽略大小写re.S 忽略.的关系，让.可以匹配出\n可以用|连接匹配模式import rea = "aasdssa,i123ja5sd4n,lai,lbi,lci,aasd"[] 字符种类，匹配方括号内的任意字符，括号内每个字符是 或 的关系#输出所有数字r = re.findall('[0-9]',a)print(r)#查0-3r1 = re.

拓扑排序import random# 第一行对应起点，第二行对应终点arr = [[0,0,1,3,2,4,5],[1,2,3,4,5,5,1]]arr1 = [[0,0,1,3,2,5],[1,2,3,4,5,1]]print(arr)[[0, 0, 1, 3, 2, 4, 5], [1, 2, 3, 4, 5, 5, 1]]定义图邻接表的形式让字典中的键表示各个结点，值则表示各个结点的对应链表（即各个邻接点）。其中，链表用列表list()来进行存储，而链表中的各个结点用元组t

LENET卷积神经网络import torchimport torch.nn as nnimport torch.utils.data as Datafrom torchvision import datasets,transformsimport torchvisionfrom torch.autograd import Variableimport numpy# 加载数据和数据处理transform = transforms.Compose([transforms.ToTensor(

中心极限定理用掷骰子来模拟import matplotlib.pyplot as pltimport numpyimport random#两个骰子的结果 2-12def dic(n): #投n次 result = numpy.zeros((13)) print(result) for i in range(1,n+1): a = random.randint(1,6) b = random.randint(1,6)

激活函数sigmoidinput = torch.randn(2,3)print(input)tensor([[-0.2863, 0.1606, -0.6738], [ 0.3379, -0.5613, 0.3672]])X = torch.tensor([[1,2,3],[2,3,4]])Y = mod(X)print(Y)------------------------------------------------------------------------

希尔排序import random'''生成随机数，这里用到的叫列表推导式子，详见：https://blog.csdn.net/weixin_42769131/article/details/104214098'''arr = [random.randint(1,20) for i in range(0,10)]print(arr)len(arr)[3, 12, 20, 2, 16, 14, 14, 11, 7, 14]10#希尔排序def ShellSort(arr, n):