AI on Yaohong

How backward and step are associated with model paramters update?

Wed, 17 Nov 2021 20:27:20 +0800

How are backward and step associated with model paramters update?

optimizer accept the paramters of the model, it can update the parameters, but how is loss function associated with paramters?

loss.backward()

optimizer.step()

REFERENCE:

1.pytorch - connection between loss.backward() and optimizer.step()

2.https://pytorch.org/tutorials/beginner/former_torchies/nnft_tutorial.html#forward-and-backward-function-hooks

nn_Module

Tue, 16 Nov 2021 20:27:20 +0800

nn_Module

1.Where are module parameters configured?

The parameters are stored in the network node which is one of points of a network layer. Neural network layer is defined in init method of module and need to be defined as class variable;

import torch.nn as nn
import numpy as np
class TorchDNN(nn.Module):

 def __init__(self, input, hidden, output):
 super(TorchDNN, self).__init__();
 layer_hidden = nn.Linear(input, hidden, bias = True);
 def forward(self, input_data):
 pass

x = np.array([1, 2, 3])
torch_model = TorchDNN(len(x), 5, 3)
print(torch_model.state_dict())
# OUTPUT:
# OrderedDict()

Network layer should be defined as a variable of Module class;

Understanding arange, unsqueeze, repeat, stack methods in Pytorch

Fri, 30 Jul 2021 20:26:20 +0800

Understanding arange, unsqueeze, repeat, stack methods in Pytorch

torch.arange(start=0, end, step=1) return 1-D tensor of size (end-start)/step which value begin from start and each value take with common differences step.
torch.unsqueeze(input, dim) return a new tensor with a dimension of size one insterted at specified position; A dim value within the range [-input.dim() - 1, input.dim() + 1) can be used.
tensor.repeat(size*) return a tensor; the new shape of tensor is that original shape multiplied by arguments correspondingly, if the number of paramter don’t match the original shape, then last dimension of new shape = the last dimension of original shape * last paramter;

L1 L2 Regularization - Optimizer

Mon, 12 Jul 2021 20:26:20 +0800

Optimizer: L1 L2 Regularization

L1,L2 Loss function mean different type of loss function.

L1: sum(Y-f(x)) lasso
L2: sum(Y-f(x))^2 Ridge

L1, L2 regularization :

Y_predict = E(w_i(x_i)+b_i)

MES = E(Y-Y_predict)^2

L1: loss = MSE + 入E|w_i|
L2: loss = MES + 入E(w_i)^2

What does penalize the weights?

It means add another parameters to the loss function, so that the greater the weight, the higher the loss function value. That makes the weight parameters to be less or smaller.

How to Label Voice with Praat for Machine Learning

Sat, 10 Jul 2021 11:34:20 +0800

How to Label Voice with Praat for Machine Learning

1.Install

1.1 Download praat

1.Open Praat: doing Phonetics by Computer website;

2.Choose your OS system on download area in the upper left conner of website;

3.Then click the praat6150_mac.dmg or praat6150_win64.zip to download file;

For example, my os is MacOS, in my case I should download praat6150_mac.dmg and install it.

Option: You can also download the file from github, referce to Praat in github

1.2 Install Phonetic symbols

If you want to see good-quality phonetic characters on your screen and in your clipboard, you have to install the Charis SIL and/or the Doulos SIL font.

Anacode simple usage

Sat, 26 Jun 2021 13:52:53 +0800

Anacode simple usage

1.1 Download and install –Mac os

Download file: click to download

Install after download.

Run command in terminal to see your anconda version:

$conda -V
conda 4.10.1

Use conda info to see conda configuration:

(base) $ conda info

2.Anaconda Usage

2.1 List all enviroments

(base) $ conda info -e
# conda environments:
#
base /Users/Rhys/opt/anaconda3

2.1 create an enviroment

(base) $ conda create -n py36 python=3.6

2.2 activate an enviroment

(base) $ conda activate py36
(py36) $

The environment had changed after activating;

Simple AI expert Enhanced Loop

Mon, 21 Jun 2021 21:19:20 +0800

Simple AI expert Enhanced Loop

Habit: Daily plan, weekly plan, month plan, 10 minute reading, Daily self-examination

Loop1: Assumption->design a experiment->do->feedback->conclusion

Loop2: Choose a subject->Weekly Share to my classmates->Feedback and update -> Make another share;

The Simple Implement of BatchNorm2D

Thu, 27 May 2021 12:30:20 +0800

The Simple Implement of BatchNorm2D

The first is that instead of whiteningthe features in layer inputs and outputs jointly, we will normalize each scalar feature independently, by making ithave the mean of zero and the variance of 1. For a layer with d-dimensional inputx = (x(1). . . x(d)), we will nor-malize each dimension

1.MyBatchNorm2D

import numpy as np;
class MyBatchNorm2D:

 def __init__(self):
 pass

 def forward(self, x):
 x = np.array(x);
 mean = np.mean(x);
 standard_deviation = np.sqrt(np.var(x) + 1e-05);
 x_norm = (x - mean) / standard_deviation;
 return x_norm;

input = [[[[ 1.1713, -10.7508],
 [-2.0155, -0.5290],
 [-0.2751, 1.0233]],
 [[-1.4446, -0.8337],
 [-1.0429, -0.8856],
 [ 5.3324, 7.6233]]],
 [[[ 2.1079, 1.6039],
 [-0.8938, 1.1655],
 [ 8.0355, -0.4911]],
 [[ 3.6337, 10.3400],
 [-1.5365, 0.7931],
 [ 0.8472, 1.1318]]]];
x = np.array(input);
bn = MyBatchNorm2D();
x_norm = bn.forward(input);
print("x_norm:", x_norm);

print("np.mean: ", np.mean(np.array(input)));
print("np.var: " , np.var(np.array(input)));
print("MyBatchNorm2D np.mean: ", np.mean(np.array(x_norm)));
print("MyBatchNorm2D np.var: " , np.var(np.array(x_norm)));

# OUTPUT:
# x_norm: [[[[ 0.0414345 -2.92181622]
# [-0.75064805 -0.38117689]
# [-0.31806977 0.00464894]]
# [[-0.60875025 -0.4569104 ]
# [-0.50890728 -0.4698102 ]
# [ 1.07568036 1.64508601]]]
# [[[ 0.27422743 0.14895769]
# [-0.47184832 0.0399929 ]
# [ 1.74753876 -0.3717568 ]]
# [[ 0.65346666 2.3203247 ]
# [-0.63159209 -0.05256752]
# [-0.0391209 0.03161673]]]]
# np.mean: 1.0045958333333334
# np.var: 16.18707780123264
# MyBatchNorm2D np.mean: 0.0
# MyBatchNorm2D np.var: 0.9999993822236513

2.Using BatchNorm2d in torch

input = [[[[ 1.1713, -10.7508],
 [-2.0155, -0.5290],
 [-0.2751, 1.0233]],
 [[-1.4446, -0.8337],
 [-1.0429, -0.8856],
 [ 5.3324, 7.6233]]],
 [[[ 2.1079, 1.6039],
 [-0.8938, 1.1655],
 [ 8.0355, -0.4911]],
 [[ 3.6337, 10.3400],
 [-1.5365, 0.7931],
 [ 0.8472, 1.1318]]]];

import torch
import torch.nn as nn
input = torch.tensor(input);
bn = nn.BatchNorm2d(2, momentum=None, affine=False, track_running_stats=None)
x_norm = bn(input)
print("BatchNorm2d new_x:", x_norm);

import numpy as np;
print("BatchNorm2d np.mean: " , np.mean(np.array(x_norm)));
print("BatchNorm2d np.var: " , np.var(np.array(x_norm)));

# OUTPUT:
# BatchNorm2d new_x: tensor([[[[ 0.2864, -2.6606],
# [-0.5013, -0.1339],
# [-0.0711, 0.2498]],
# [[-0.9184, -0.7553],
# [-0.8112, -0.7692],
# [ 0.8903, 1.5017]]],
# [[[ 0.5179, 0.3933],
# [-0.2241, 0.2850],
# [ 1.9831, -0.1245]],
# [[ 0.4369, 2.2267],
# [-0.9429, -0.3212],
# [-0.3067, -0.2308]]]])
# BatchNorm2d np.mean: -9.934108e-09
# BatchNorm2d np.var: 0.99999934

REFERENCE:

1.Torch nn.BatchNorm2d

model(x) vs model.forward(x)

Mon, 24 May 2021 11:00:20 +0800

model(x) vs model.forward(x)

__call__ magic method in nn.Module will invoke forward() method and take care of hooks and states that python allows, so we should use model(x) rather than call model.forward(x) directly.

REFERENCE:

1.Why there are different output between model.forward(input) and model(input)

2.Calling forward function without .forward()

3.torch.nn.module codes

DNN RNN CNN codes

Tue, 04 May 2021 08:27:20 +0800

Simple DNN RNN CNN example codes

1.DNN-Deep neural network


import numpy as np;
class myDNN:

 # 3 * 5 * 2
 def __init__(self, input, hidden, output):
 # hidden random weight 
 # Note: hidden_weight can be the shape of (input,hidden); correspondingly, `self.hidden_out` should equal `np.dot(input_data, self.hidden_weight)` to accord with hidden_weight shape.
 self.hidden_weight = np.random.rand(hidden, input); 

 self.hidden_bias = np.random.rand(hidden);

 # hidden random weight 
 self.output_weight = np.random.rand(output,hidden);
 self.output_bias = np.random.rand(output);

 # 
 def forward(self, input_data):
 self.hidden_out = np.dot(input_data, self.hidden_weight.T) + self.hidden_bias;

 self.output_out = np.dot(self.hidden_out, self.output_weight.T) + self.output_bias;

# Usage:
dnn = myDNN(3,5,3);
print("hidden_weight",dnn.hidden_weight)
print("hidden_bias:",dnn.hidden_bias)
print("output_weight",dnn.output_weight)
print("output_bias",dnn.output_bias)

x = np.array([1, 2, 3]) #inut
dnn.forward(x);
print("output_out",dnn.output_out)

# output:
# hidden_weight [[0.99663996 0.39342568 0.5312192 ]
# [0.0798744 0.50312289 0.86241405]
# [0.17138496 0.6761287 0.70645906]
# [0.61662379 0.69389404 0.16623206]
# [0.71213402 0.30800932 0.64149244]]
# hidden_bias: [0.81517457 0.56115705 0.3089624 0.84450962 0.93530796]
# output_weight [[0.34466034 0.31119367 0.12883636 0.34135026 0.43802589]
# [0.31553914 0.16063241 0.8179255 0.52314575 0.79439618]
# [0.86730239 0.25280671 0.20375421 0.78095429 0.67368635]]
# output_bias [0.5588883 0.98722366 0.21507382]
# output_out [ 6.8078659 11.30086755 11.16252686]

1.1 Use DNN in torch

import torch.nn as nn
class TorchDNN(nn.Module):

 def __init__(self, input, hidden, output):
 super(TorchDNN, self).__init__();
 self.layer_hidden = nn.Linear(input, hidden, bias = True);
 self.layer_output = nn.Linear(hidden, output, bias = True);

 # 
 def forward(self, input_data):
 self.hidden_out = self.layer_hidden(input_data);
 self.output_out = self.layer_output(self.hidden_out);

x = np.array([1, 2, 3])
torch_model = TorchDNN(len(x), 5, 3)
print(torch_model.state_dict())

# OrderedDict([('layer_hidden.weight', 
# tensor([[-0.5216, -0.5690, 0.4181],
# [-0.3142, 0.1489, 0.5071],
# [ 0.0295, 0.3381, 0.4401],
# [-0.4697, 0.0732, -0.0328],
# [ 0.5250, 0.1540, 0.2086]])), 
# ('layer_hidden.bias', tensor([-0.5134, 0.2645, -0.3366, -0.0597, 0.0159])), 
# ('layer_output.weight', 
# tensor([[ 0.2770, -0.3408, -0.3145, -0.3686, 0.1060],
# [ 0.1268, 0.0729, -0.3838, 0.2850, 0.1438],
# [ 0.1645, -0.0497, 0.1029, 0.1088, -0.0536]])), 
# ('layer_output.bias', tensor([ 0.0908, -0.1240, 0.2800]))])

2.RNN-Recurrent neural network


import numpy as np;
class myRNN:

 def __init__(self, input, hidden ):
 # random weight
 self.input_hidden_weight = np.random.randint(-10000,10000,(hidden, input))/10000;
 self.hidden_hidden_weight = np.random.randint(-10000,10000,(hidden))/10000;

 # random bias
 self.input_hidden_bias = np.random.randint(-10000,10000,(hidden))/10000;
 self.hidden_hidden_bias = np.random.randint(-10000,10000,(hidden))/10000;
 # self.input_hidden_bias = np.zeros(hidden);
 # self.hidden_hidden_bias = np.zeros(hidden);
 self.hidden_size = hidden

 
 def forward(self, input_data):
 self.last_hidden_output = np.zeros([self.hidden_size]);
 output = []
 for item in input_data:
 # ht=tanh(W_ih * x_t + b_ih  + W_hh*h_(t−1)+b_hh)
 hidden_cur = np.dot(item, self.input_hidden_weight.T) + self.input_hidden_bias;
 hidden_pre = np.dot(self.last_hidden_output, self.hidden_hidden_weight.T) + self.hidden_hidden_bias;

 hidden_output = np.tanh( hidden_cur + hidden_pre )
 output.append(hidden_output)
 self.last_hidden_output = hidden_output;

 return np.array(output), hidden_output;

# diy_model = myRNN(w_ih, w_hh, hidden_size)
x = np.array([[1, 2, 3], [3, 4, 5], [5, 6, 7]]) 
input_size = 3;
hidden_size = 4;
diy_model = myRNN(input_size,hidden_size)
output, hidden_output = diy_model.forward(x)
print("myRNN process output: ", output)
print("myRNN hidden_output:", hidden_output)

# output:
# myRNN process output: [[-0.62745049 -0.99314575 -0.96754221 -0.9965258 ]
# [-0.99542912 -0.99962783 -0.99965698 -0.99998354]
# [-0.99983032 -0.99992543 -0.9999868 -0.99999971]]
# myRNN hidden_output: [-0.99983032 -0.99992543 -0.9999868 -0.99999971]

2.1 Use RNN in torch

import torch.nn as nn;
import torch;
import numpy as np;
class TorchRNN(nn.Module):

 def __init__(self, input_size, hidden):
 super(TorchRNN,self).__init__();
 self.layer = nn.RNN(input_size, hidden, batch_first=True);

 def forward(self, x):
 return self.layer(x)


torch_model = TorchRNN(3, 4)
print(torch_model.state_dict())

x = np.array([[1, 2, 3], [3, 4, 5], [5, 6, 7]]) 
torch_x = torch.FloatTensor([x])
output, h = torch_model.forward(torch_x)
print("output:", output.detach().numpy())
print("h:",h.detach().numpy())

# output: 
# OrderedDict([('layer.weight_ih_l0', tensor([[ 0.0922, 0.2786, -0.4514],
# [ 0.3809, 0.2628, -0.4460],
# [-0.4951, -0.3599, -0.4961],
# [ 0.3794, 0.3397, 0.3185]])), ('layer.weight_hh_l0', tensor([[-0.1330, -0.1843, -0.2618, 0.4246],
# [ 0.4154, -0.3578, -0.4181, -0.4291],
# [ 0.3608, -0.2349, 0.4631, 0.4873],
# [ 0.4886, 0.0285, -0.0490, 0.2928]])), ('layer.bias_ih_l0', tensor([-0.1421, -0.3572, -0.2087, -0.0319])), ('layer.bias_hh_l0', tensor([-0.3799, 0.1126, -0.1766, 0.2630]))])
# output: [[[-0.8416229 -0.589054 -0.99585485 0.9778193 ]
# [-0.45533973 -0.3993926 -0.9999862 0.99957436]
# [-0.6221984 0.05736368 -0.99999994 0.9999955 ]]]
# h: [[[-0.6221984 0.05736368 -0.99999994 0.9999955 ]]]

3.CNN-Convolutional neural network

import numpy as np;
class MyCNN:

 # I don't know how do filters work.
 def __init__(self, in_channel, out_channel, kernel_size):
 # random weight
 # (out_channel, in_channel, kernel_size, kernel_size)
 # self.kernel_weight = np.random.randint(-10000,10000,(out_channel, in_channel, kernel_size, kernel_size))/10000;
 self.kernel_weight = np.array([[[[ 0.0106, -0.1561, 0.0984],
 [ 0.1468, 0.1580, -0.1404],
 [ 0.0856, 0.0780, 0.0636]],
 [[-0.1620, 0.2318, 0.0486],
 [-0.2214, -0.2046, 0.1070],
 [ 0.1609, 0.0160, -0.0374]]],
 [[[ 0.1876, -0.2056, 0.1858],
 [-0.1288, 0.0065, -0.0145],
 [-0.1080, 0.1519, 0.0581]],
 [[-0.0749, 0.2289, -0.0890],
 [ 0.0611, 0.0398, -0.1293],
 [ 0.0911, -0.0264, -0.2104]]]]);
 self.in_channel = in_channel;
 self.out_channel = out_channel;
 self.kernel_size = kernel_size;

 # c*h*w
 def forward(self, input_data):
 output = [];
 input_shape = input_data.shape;

 idx_start = np.int(np.floor( (self.kernel_size)/2)) ;
 width = input_shape[1];
 height = input_shape[2];
 in_channel = input_shape[0];

 for o_c in range(self.out_channel):
 piece_of_out_channel = np.zeros(( width-(idx_start*2), height-(idx_start*2) ));
 # print("piece_of_out_channel:", piece_of_out_channel.shape)
 # width
 for idx_height in range(idx_start, height - idx_start): 
 # height
 for idx_width in range(idx_start, width - idx_start ):
 # kernel_shape_input
 kernel_shape_input = input_data[:, idx_height-idx_start: idx_height+idx_start+1, idx_width-idx_start :idx_width+idx_start+1 ];

 out = self.kernel_weight[o_c] * kernel_shape_input;
 out = np.sum(out)

 # assign value
 idx_h = idx_height - idx_start;
 idx_w = idx_width - idx_start
 piece_of_out_channel[idx_h][idx_w] = out;

 output.append(piece_of_out_channel);
 return output;



# x = np.random.randint(0,10000,(2, 6, 6))/100;
# x = random.astype(int)
x = np.array([[[61,93,18,31,2,49]
 ,[12,62,32,60,58,30]
 ,[49,64,38,74,59,29]
 ,[71,34,29,88,59,41]
 ,[91,72,36,94,79,29]
 ,[17,15,86,29,84,53]]

 ,[[31,25,15,16,35,20]
 ,[76,45,82,88,49,99]
 ,[56,46,82,72,26,55]
 ,[7, 86,32,29,82,91]
 ,[76,68,17,50,19,53]
 ,[87,21,58,35,81,46]]
 ]);
# print(x);
print("x.shape:",x.shape)

myCNN = MyCNN(x.shape[0], 2, 3);
print(myCNN.kernel_weight)
output = myCNN.forward(x)
print("myCNN output:",output)

# output:
# x.shape: (2, 6, 6)
# myCNN output: [array([[-2.5093, 9.0098, -0.2033, 28.9 ],
# [ 6.5155, 27.3464, 0.7038, 14.5031],
# [24.2218, 16.1092, 23.2223, 16.9067],
# [29.6749, 2.0986, 16.8128, 45.025 ]]), 
# array([[-14.77 , -4.3335, 5.0665, 3.2378],
# [-28.2207, 18.1968, 11.889 , -27.3557],
# [ -2.748 , 22.5508, 10.6013, -19.0372],
# [ 22.0148, 9.1788, -22.0313, 9.5176]])]

3.1 Use CNN in torch



import torch;
import torch.nn as nn;
class TorchCNN(nn.Module):

 def __init__(self, in_channel, out_channel, kernel_size ):
 super().__init__();
 self.conv2d = nn.Conv2d(in_channel, out_channel, kernel_size, bias=False);

 def forward(self, input_data):
 return self.conv2d(input_data);

in_channel = x.shape[0];
torchcnn = TorchCNN(in_channel, 2, 3);
print("torchcnn weight:", torchcnn.state_dict())
print("torchcnn weight shape:", torchcnn.state_dict()['conv2d.weight'].numpy().shape)
# torchcnn weight shape: (2, 2, 3, 3) => (out_channel, in_channel, kernel_size, kernel_size)
torch_x = torch.FloatTensor([x])
out = torchcnn.forward(torch_x);
print("TorchCNN out: ", out)


# output
# torchcnn weight: OrderedDict([('conv2d.weight', tensor(
# [[[[ 0.0106, -0.1561, 0.0984],
# [ 0.1468, 0.1580, -0.1404],
# [ 0.0856, 0.0780, 0.0636]],
# [[-0.1620, 0.2318, 0.0486],
# [-0.2214, -0.2046, 0.1070],
# [ 0.1609, 0.0160, -0.0374]]],
# [[[ 0.1876, -0.2056, 0.1858],
# [-0.1288, 0.0065, -0.0145],
# [-0.1080, 0.1519, 0.0581]],
# [[-0.0749, 0.2289, -0.0890],
# [ 0.0611, 0.0398, -0.1293],
# [ 0.0911, -0.0264, -0.2104]]]]))])
# TorchCNN out: tensor([[[[ -2.5066, 9.0144, -0.1983, 28.9003],
# [ 6.5160, 27.3456, 0.7094, 14.5056],
# [ 24.2262, 16.1086, 23.2279, 16.9102],
# [ 29.6763, 2.1047, 16.8210, 45.0250]],
# [[-14.7564, -4.3273, 5.0752, 3.2491],
# [-28.2115, 18.1981, 11.8975, -27.3447],
# [ -2.7442, 22.5540, 10.6096, -19.0247],
# [ 22.0166, 9.1837, -22.0241, 9.5211]]]],
# grad_fn=<MkldnnConvolutionBackward>)

Use Opencv stitching_detailed To Stitch Segmentation image

Thu, 29 Apr 2021 18:36:00 +0800

Use Opencv stitching_detailed To Stitch Segmentation image

Environment:

python version 3.7
opencv-python version 4.5.1.48

1.Download stitching_detailed file save it with file name stitching_detailed.py;

2.Run the command;

$python.exe stitching_detailed.py image_1.png image_2.png image_3.png image_4.png image_5.png image_6.png image_7.png image_8.png image_9.png origin.png --features=brisk --matcher=affine

Note that: image 1~9 is Segmentation images and origin.png is a full picture.

REFERENCE:

stitching_detailed

stitching_detailed.py source codes is follow:

"""
Stitching sample (advanced)
===========================
Show how to use Stitcher API from python.
"""

# Python 2/3 compatibility
from __future__ import print_function

import argparse
from collections import OrderedDict

import cv2 as cv
import numpy as np

EXPOS_COMP_CHOICES = OrderedDict()
EXPOS_COMP_CHOICES['gain_blocks'] = cv.detail.ExposureCompensator_GAIN_BLOCKS
EXPOS_COMP_CHOICES['gain'] = cv.detail.ExposureCompensator_GAIN
EXPOS_COMP_CHOICES['channel'] = cv.detail.ExposureCompensator_CHANNELS
EXPOS_COMP_CHOICES['channel_blocks'] = cv.detail.ExposureCompensator_CHANNELS_BLOCKS
EXPOS_COMP_CHOICES['no'] = cv.detail.ExposureCompensator_NO

BA_COST_CHOICES = OrderedDict()
BA_COST_CHOICES['ray'] = cv.detail_BundleAdjusterRay
BA_COST_CHOICES['reproj'] = cv.detail_BundleAdjusterReproj
BA_COST_CHOICES['affine'] = cv.detail_BundleAdjusterAffinePartial
BA_COST_CHOICES['no'] = cv.detail_NoBundleAdjuster

FEATURES_FIND_CHOICES = OrderedDict()
try:
 cv.xfeatures2d_SURF.create() # check if the function can be called
 FEATURES_FIND_CHOICES['surf'] = cv.xfeatures2d_SURF.create
except (AttributeError, cv.error) as e:
 print("SURF not available")
# if SURF not available, ORB is default
FEATURES_FIND_CHOICES['orb'] = cv.ORB.create
try:
 FEATURES_FIND_CHOICES['sift'] = cv.xfeatures2d_SIFT.create
except AttributeError:
 print("SIFT not available")
try:
 FEATURES_FIND_CHOICES['brisk'] = cv.BRISK_create
except AttributeError:
 print("BRISK not available")
try:
 FEATURES_FIND_CHOICES['akaze'] = cv.AKAZE_create
except AttributeError:
 print("AKAZE not available")

SEAM_FIND_CHOICES = OrderedDict()
SEAM_FIND_CHOICES['gc_color'] = cv.detail_GraphCutSeamFinder('COST_COLOR')
SEAM_FIND_CHOICES['gc_colorgrad'] = cv.detail_GraphCutSeamFinder('COST_COLOR_GRAD')
SEAM_FIND_CHOICES['dp_color'] = cv.detail_DpSeamFinder('COLOR')
SEAM_FIND_CHOICES['dp_colorgrad'] = cv.detail_DpSeamFinder('COLOR_GRAD')
SEAM_FIND_CHOICES['voronoi'] = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM)
SEAM_FIND_CHOICES['no'] = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)

ESTIMATOR_CHOICES = OrderedDict()
ESTIMATOR_CHOICES['homography'] = cv.detail_HomographyBasedEstimator
ESTIMATOR_CHOICES['affine'] = cv.detail_AffineBasedEstimator

WARP_CHOICES = (
 'spherical',
 'plane',
 'affine',
 'cylindrical',
 'fisheye',
 'stereographic',
 'compressedPlaneA2B1',
 'compressedPlaneA1.5B1',
 'compressedPlanePortraitA2B1',
 'compressedPlanePortraitA1.5B1',
 'paniniA2B1',
 'paniniA1.5B1',
 'paniniPortraitA2B1',
 'paniniPortraitA1.5B1',
 'mercator',
 'transverseMercator',
)

WAVE_CORRECT_CHOICES = OrderedDict()
WAVE_CORRECT_CHOICES['horiz'] = cv.detail.WAVE_CORRECT_HORIZ
WAVE_CORRECT_CHOICES['no'] = None
WAVE_CORRECT_CHOICES['vert'] = cv.detail.WAVE_CORRECT_VERT

BLEND_CHOICES = ('multiband', 'feather', 'no',)

parser = argparse.ArgumentParser(
 prog="stitching_detailed.py", description="Rotation model images stitcher"
)
parser.add_argument(
 'img_names', nargs='+',
 help="Files to stitch", type=str
)
parser.add_argument(
 '--try_cuda',
 action='store',
 default=False,
 help="Try to use CUDA. The default value is no. All default values are for CPU mode.",
 type=bool, dest='try_cuda'
)
parser.add_argument(
 '--work_megapix', action='store', default=0.6,
 help="Resolution for image registration step. The default is 0.6 Mpx",
 type=float, dest='work_megapix'
)
parser.add_argument(
 '--features', action='store', default=list(FEATURES_FIND_CHOICES.keys())[0],
 help="Type of features used for images matching. The default is '%s'." % list(FEATURES_FIND_CHOICES.keys())[0],
 choices=FEATURES_FIND_CHOICES.keys(),
 type=str, dest='features'
)
parser.add_argument(
 '--matcher', action='store', default='homography',
 help="Matcher used for pairwise image matching. The default is 'homography'.",
 choices=('homography', 'affine'),
 type=str, dest='matcher'
)
parser.add_argument(
 '--estimator', action='store', default=list(ESTIMATOR_CHOICES.keys())[0],
 help="Type of estimator used for transformation estimation. The default is '%s'." % list(ESTIMATOR_CHOICES.keys())[0],
 choices=ESTIMATOR_CHOICES.keys(),
 type=str, dest='estimator'
)
parser.add_argument(
 '--match_conf', action='store',
 help="Confidence for feature matching step. The default is 0.3 for ORB and 0.65 for other feature types.",
 type=float, dest='match_conf'
)
parser.add_argument(
 '--conf_thresh', action='store', default=1.0,
 help="Threshold for two images are from the same panorama confidence.The default is 1.0.",
 type=float, dest='conf_thresh'
)
parser.add_argument(
 '--ba', action='store', default=list(BA_COST_CHOICES.keys())[0],
 help="Bundle adjustment cost function. The default is '%s'." % list(BA_COST_CHOICES.keys())[0],
 choices=BA_COST_CHOICES.keys(),
 type=str, dest='ba'
)
parser.add_argument(
 '--ba_refine_mask', action='store', default='xxxxx',
 help="Set refinement mask for bundle adjustment. It looks like 'x_xxx', "
 "where 'x' means refine respective parameter and '_' means don't refine, "
 "and has the following format:<fx><skew><ppx><aspect><ppy>. "
 "The default mask is 'xxxxx'. "
 "If bundle adjustment doesn't support estimation of selected parameter then "
 "the respective flag is ignored.",
 type=str, dest='ba_refine_mask'
)
parser.add_argument(
 '--wave_correct', action='store', default=list(WAVE_CORRECT_CHOICES.keys())[0],
 help="Perform wave effect correction. The default is '%s'" % list(WAVE_CORRECT_CHOICES.keys())[0],
 choices=WAVE_CORRECT_CHOICES.keys(),
 type=str, dest='wave_correct'
)
parser.add_argument(
 '--save_graph', action='store', default=None,
 help="Save matches graph represented in DOT language to <file_name> file.",
 type=str, dest='save_graph'
)
parser.add_argument(
 '--warp', action='store', default=WARP_CHOICES[0],
 help="Warp surface type. The default is '%s'." % WARP_CHOICES[0],
 choices=WARP_CHOICES,
 type=str, dest='warp'
)
parser.add_argument(
 '--seam_megapix', action='store', default=0.1,
 help="Resolution for seam estimation step. The default is 0.1 Mpx.",
 type=float, dest='seam_megapix'
)
parser.add_argument(
 '--seam', action='store', default=list(SEAM_FIND_CHOICES.keys())[0],
 help="Seam estimation method. The default is '%s'." % list(SEAM_FIND_CHOICES.keys())[0],
 choices=SEAM_FIND_CHOICES.keys(),
 type=str, dest='seam'
)
parser.add_argument(
 '--compose_megapix', action='store', default=-1,
 help="Resolution for compositing step. Use -1 for original resolution. The default is -1",
 type=float, dest='compose_megapix'
)
parser.add_argument(
 '--expos_comp', action='store', default=list(EXPOS_COMP_CHOICES.keys())[0],
 help="Exposure compensation method. The default is '%s'." % list(EXPOS_COMP_CHOICES.keys())[0],
 choices=EXPOS_COMP_CHOICES.keys(),
 type=str, dest='expos_comp'
)
parser.add_argument(
 '--expos_comp_nr_feeds', action='store', default=1,
 help="Number of exposure compensation feed.",
 type=np.int32, dest='expos_comp_nr_feeds'
)
parser.add_argument(
 '--expos_comp_nr_filtering', action='store', default=2,
 help="Number of filtering iterations of the exposure compensation gains.",
 type=float, dest='expos_comp_nr_filtering'
)
parser.add_argument(
 '--expos_comp_block_size', action='store', default=32,
 help="BLock size in pixels used by the exposure compensator. The default is 32.",
 type=np.int32, dest='expos_comp_block_size'
)
parser.add_argument(
 '--blend', action='store', default=BLEND_CHOICES[0],
 help="Blending method. The default is '%s'." % BLEND_CHOICES[0],
 choices=BLEND_CHOICES,
 type=str, dest='blend'
)
parser.add_argument(
 '--blend_strength', action='store', default=5,
 help="Blending strength from [0,100] range. The default is 5",
 type=np.int32, dest='blend_strength'
)
parser.add_argument(
 '--output', action='store', default='result.jpg',
 help="The default is 'result.jpg'",
 type=str, dest='output'
)
parser.add_argument(
 '--timelapse', action='store', default=None,
 help="Output warped images separately as frames of a time lapse movie, "
 "with 'fixed_' prepended to input file names.",
 type=str, dest='timelapse'
)
parser.add_argument(
 '--rangewidth', action='store', default=-1,
 help="uses range_width to limit number of images to match with.",
 type=int, dest='rangewidth'
)

__doc__ += '\n' + parser.format_help()


def get_matcher(args):
 try_cuda = args.try_cuda
 matcher_type = args.matcher
 if args.match_conf is None:
 if args.features == 'orb':
 match_conf = 0.3
 else:
 match_conf = 0.65
 else:
 match_conf = args.match_conf
 range_width = args.rangewidth
 if matcher_type == "affine":
 matcher = cv.detail_AffineBestOf2NearestMatcher(False, try_cuda, match_conf)
 elif range_width == -1:
 matcher = cv.detail.BestOf2NearestMatcher_create(try_cuda, match_conf)
 else:
 matcher = cv.detail.BestOf2NearestRangeMatcher_create(range_width, try_cuda, match_conf)
 return matcher


def get_compensator(args):
 expos_comp_type = EXPOS_COMP_CHOICES[args.expos_comp]
 expos_comp_nr_feeds = args.expos_comp_nr_feeds
 expos_comp_block_size = args.expos_comp_block_size
 # expos_comp_nr_filtering = args.expos_comp_nr_filtering
 if expos_comp_type == cv.detail.ExposureCompensator_CHANNELS:
 compensator = cv.detail_ChannelsCompensator(expos_comp_nr_feeds)
 # compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
 elif expos_comp_type == cv.detail.ExposureCompensator_CHANNELS_BLOCKS:
 compensator = cv.detail_BlocksChannelsCompensator(
 expos_comp_block_size, expos_comp_block_size,
 expos_comp_nr_feeds
 )
 # compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
 else:
 compensator = cv.detail.ExposureCompensator_createDefault(expos_comp_type)
 return compensator


def main():
 args = parser.parse_args()
 img_names = args.img_names
 print(img_names)
 work_megapix = args.work_megapix
 seam_megapix = args.seam_megapix
 compose_megapix = args.compose_megapix
 conf_thresh = args.conf_thresh
 ba_refine_mask = args.ba_refine_mask
 wave_correct = WAVE_CORRECT_CHOICES[args.wave_correct]
 if args.save_graph is None:
 save_graph = False
 else:
 save_graph = True
 warp_type = args.warp
 blend_type = args.blend
 blend_strength = args.blend_strength
 result_name = args.output
 if args.timelapse is not None:
 timelapse = True
 if args.timelapse == "as_is":
 timelapse_type = cv.detail.Timelapser_AS_IS
 elif args.timelapse == "crop":
 timelapse_type = cv.detail.Timelapser_CROP
 else:
 print("Bad timelapse method")
 exit()
 else:
 timelapse = False
 finder = FEATURES_FIND_CHOICES[args.features]()
 seam_work_aspect = 1
 full_img_sizes = []
 features = []
 images = []
 is_work_scale_set = False
 is_seam_scale_set = False
 is_compose_scale_set = False
 for name in img_names:
 full_img = cv.imread(cv.samples.findFile(name))
 if full_img is None:
 print("Cannot read image ", name)
 exit()
 full_img_sizes.append((full_img.shape[1], full_img.shape[0]))
 if work_megapix < 0:
 img = full_img
 work_scale = 1
 is_work_scale_set = True
 else:
 if is_work_scale_set is False:
 work_scale = min(1.0, np.sqrt(work_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
 is_work_scale_set = True
 img = cv.resize(src=full_img, dsize=None, fx=work_scale, fy=work_scale, interpolation=cv.INTER_LINEAR_EXACT)
 if is_seam_scale_set is False:
 seam_scale = min(1.0, np.sqrt(seam_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
 seam_work_aspect = seam_scale / work_scale
 is_seam_scale_set = True
 img_feat = cv.detail.computeImageFeatures2(finder, img)
 features.append(img_feat)
 img = cv.resize(src=full_img, dsize=None, fx=seam_scale, fy=seam_scale, interpolation=cv.INTER_LINEAR_EXACT)
 images.append(img)

 matcher = get_matcher(args)
 p = matcher.apply2(features)
 matcher.collectGarbage()

 if save_graph:
 with open(args.save_graph, 'w') as fh:
 fh.write(cv.detail.matchesGraphAsString(img_names, p, conf_thresh))

 indices = cv.detail.leaveBiggestComponent(features, p, conf_thresh)
 img_subset = []
 img_names_subset = []
 full_img_sizes_subset = []
 for i in range(len(indices)):
 img_names_subset.append(img_names[indices[i, 0]])
 img_subset.append(images[indices[i, 0]])
 full_img_sizes_subset.append(full_img_sizes[indices[i, 0]])
 images = img_subset
 img_names = img_names_subset
 full_img_sizes = full_img_sizes_subset
 num_images = len(img_names)
 if num_images < 2:
 print("Need more images")
 exit()

 estimator = ESTIMATOR_CHOICES[args.estimator]()
 b, cameras = estimator.apply(features, p, None)
 if not b:
 print("Homography estimation failed.")
 exit()
 for cam in cameras:
 cam.R = cam.R.astype(np.float32)

 adjuster = BA_COST_CHOICES[args.ba]()
 adjuster.setConfThresh(1)
 refine_mask = np.zeros((3, 3), np.uint8)
 if ba_refine_mask[0] == 'x':
 refine_mask[0, 0] = 1
 if ba_refine_mask[1] == 'x':
 refine_mask[0, 1] = 1
 if ba_refine_mask[2] == 'x':
 refine_mask[0, 2] = 1
 if ba_refine_mask[3] == 'x':
 refine_mask[1, 1] = 1
 if ba_refine_mask[4] == 'x':
 refine_mask[1, 2] = 1
 adjuster.setRefinementMask(refine_mask)
 b, cameras = adjuster.apply(features, p, cameras)
 if not b:
 print("Camera parameters adjusting failed.")
 exit()
 focals = []
 for cam in cameras:
 focals.append(cam.focal)
 focals.sort()
 if len(focals) % 2 == 1:
 warped_image_scale = focals[len(focals) // 2]
 else:
 warped_image_scale = (focals[len(focals) // 2] + focals[len(focals) // 2 - 1]) / 2
 if wave_correct is not None:
 rmats = []
 for cam in cameras:
 rmats.append(np.copy(cam.R))
 rmats = cv.detail.waveCorrect(rmats, wave_correct)
 for idx, cam in enumerate(cameras):
 cam.R = rmats[idx]
 corners = []
 masks_warped = []
 images_warped = []
 sizes = []
 masks = []
 for i in range(0, num_images):
 um = cv.UMat(255 * np.ones((images[i].shape[0], images[i].shape[1]), np.uint8))
 masks.append(um)

 warper = cv.PyRotationWarper(warp_type, warped_image_scale * seam_work_aspect) # warper could be nullptr?
 for idx in range(0, num_images):
 K = cameras[idx].K().astype(np.float32)
 swa = seam_work_aspect
 K[0, 0] *= swa
 K[0, 2] *= swa
 K[1, 1] *= swa
 K[1, 2] *= swa
 corner, image_wp = warper.warp(images[idx], K, cameras[idx].R, cv.INTER_LINEAR, cv.BORDER_REFLECT)
 corners.append(corner)
 sizes.append((image_wp.shape[1], image_wp.shape[0]))
 images_warped.append(image_wp)
 p, mask_wp = warper.warp(masks[idx], K, cameras[idx].R, cv.INTER_NEAREST, cv.BORDER_CONSTANT)
 masks_warped.append(mask_wp.get())

 images_warped_f = []
 for img in images_warped:
 imgf = img.astype(np.float32)
 images_warped_f.append(imgf)

 compensator = get_compensator(args)
 compensator.feed(corners=corners, images=images_warped, masks=masks_warped)

 seam_finder = SEAM_FIND_CHOICES[args.seam]
 seam_finder.find(images_warped_f, corners, masks_warped)
 compose_scale = 1
 corners = []
 sizes = []
 blender = None
 timelapser = None
 # https://github.com/opencv/opencv/blob/master/samples/cpp/stitching_detailed.cpp#L725 ?
 for idx, name in enumerate(img_names):
 full_img = cv.imread(name)
 if not is_compose_scale_set:
 if compose_megapix > 0:
 compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
 is_compose_scale_set = True
 compose_work_aspect = compose_scale / work_scale
 warped_image_scale *= compose_work_aspect
 warper = cv.PyRotationWarper(warp_type, warped_image_scale)
 for i in range(0, len(img_names)):
 cameras[i].focal *= compose_work_aspect
 cameras[i].ppx *= compose_work_aspect
 cameras[i].ppy *= compose_work_aspect
 sz = (full_img_sizes[i][0] * compose_scale, full_img_sizes[i][1] * compose_scale)
 K = cameras[i].K().astype(np.float32)
 roi = warper.warpRoi(sz, K, cameras[i].R)
 corners.append(roi[0:2])
 sizes.append(roi[2:4])
 if abs(compose_scale - 1) > 1e-1:
 img = cv.resize(src=full_img, dsize=None, fx=compose_scale, fy=compose_scale,
 interpolation=cv.INTER_LINEAR_EXACT)
 else:
 img = full_img
 _img_size = (img.shape[1], img.shape[0])
 K = cameras[idx].K().astype(np.float32)
 corner, image_warped = warper.warp(img, K, cameras[idx].R, cv.INTER_LINEAR, cv.BORDER_REFLECT)
 mask = 255 * np.ones((img.shape[0], img.shape[1]), np.uint8)
 p, mask_warped = warper.warp(mask, K, cameras[idx].R, cv.INTER_NEAREST, cv.BORDER_CONSTANT)
 compensator.apply(idx, corners[idx], image_warped, mask_warped)
 image_warped_s = image_warped.astype(np.int16)
 dilated_mask = cv.dilate(masks_warped[idx], None)
 seam_mask = cv.resize(dilated_mask, (mask_warped.shape[1], mask_warped.shape[0]), 0, 0, cv.INTER_LINEAR_EXACT)
 mask_warped = cv.bitwise_and(seam_mask, mask_warped)
 if blender is None and not timelapse:
 blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
 dst_sz = cv.detail.resultRoi(corners=corners, sizes=sizes)
 blend_width = np.sqrt(dst_sz[2] * dst_sz[3]) * blend_strength / 100
 if blend_width < 1:
 blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
 elif blend_type == "multiband":
 blender = cv.detail_MultiBandBlender()
 blender.setNumBands((np.log(blend_width) / np.log(2.) - 1.).astype(np.int))
 elif blend_type == "feather":
 blender = cv.detail_FeatherBlender()
 blender.setSharpness(1. / blend_width)
 blender.prepare(dst_sz)
 elif timelapser is None and timelapse:
 timelapser = cv.detail.Timelapser_createDefault(timelapse_type)
 timelapser.initialize(corners, sizes)
 if timelapse:
 ma_tones = np.ones((image_warped_s.shape[0], image_warped_s.shape[1]), np.uint8)
 timelapser.process(image_warped_s, ma_tones, corners[idx])
 pos_s = img_names[idx].rfind("/")
 if pos_s == -1:
 fixed_file_name = "fixed_" + img_names[idx]
 else:
 fixed_file_name = img_names[idx][:pos_s + 1] + "fixed_" + img_names[idx][pos_s + 1:]
 cv.imwrite(fixed_file_name, timelapser.getDst())
 else:
 blender.feed(cv.UMat(image_warped_s), mask_warped, corners[idx])
 if not timelapse:
 result = None
 result_mask = None
 result, result_mask = blender.blend(result, result_mask)
 cv.imwrite(result_name, result)
 zoom_x = 600.0 / result.shape[1]
 dst = cv.normalize(src=result, dst=None, alpha=255., norm_type=cv.NORM_MINMAX, dtype=cv.CV_8U)
 dst = cv.resize(dst, dsize=None, fx=zoom_x, fy=zoom_x)
 cv.imshow(result_name, dst)
 cv.waitKey()

 print("Done")


if __name__ == '__main__':
 print(__doc__)
 main()
 cv.destroyAllWindows()

How does warp Perspective work?

Sat, 23 Jan 2021 16:29:20 +0800

How does warp Perspective work?

1.warp perspective with cv2

if __name__ == "__main__":
 # coordinate: (y,x), left_top, right_rop, left_bottom, right_bottom
 src = np.float32([[20.0, 0.0], [20.0 ,315.0], [186.0, 17.2], [181.0, 299.0]])
 dst = np.float32([[0.0, 0.0], [0.0, 315.0], [202.0, 7.0], [200.0, 306.0]])

 # load image
 warp_img = cv2.imread("./my_wide_angle_orig.jpg")
 warp_img = cv2.cvtColor(warp_img, cv2.COLOR_BGR2RGB)
 print("warp_img: ",warp_img.shape) # (638, 958, 3)
 width = int(warp_img.shape[1]/3)
 height = int(warp_img.shape[0]/3)
 warp_img = cv2.resize(warp_img, (width,height), interpolation=cv2.INTER_LINEAR)
 print("warp_img.shape:",warp_img.shape) # (212, 319, 3)

 ## orig image
 plt.subplot(121),
 plt.title("warp_img")
 plt.imshow(warp_img)

 # cv2 warp perspective
 cv2_matrix = cv2.getPerspectiveTransform(src, dst)
 print("cv2_matrix:\n",cv2_matrix)
 cv2_fix_img = cv2.warpPerspective(warp_img, cv2_matrix, (width,height))
 plt.subplot(122),
 plt.title('cv2_fix_img')
 plt.imshow(cv2_fix_img) 
 plt.show()

2.Implement it in our way

Step1 calculate warp matrix:

my_warp_matrix reshape:
 [[ 1.13729359e+00 -8.24289989e-18 -2.27458717e+01]
 [-6.10786436e-02 9.69843448e-01 1.22157287e+00]
 [-3.44743207e-04 -7.38466280e-05 1.00000000e+00]]

Step2. use the warp matrix to warp perspective

codes are:

Averaging histograms

Tue, 29 Dec 2020 00:49:20 +0800

Averaging histograms

An image histogram is the number of each pixel value, which is displayed in the graph.

x axis of the graph is pixel value, range from 0 to 255;

y axis of the graph is the number of this pixel value;

1.How to averaging histograms?

Our goal is to generate a new image with a more even histogram distribution.

How Keras add two layers?

Sun, 13 Dec 2020 13:44:00 +0800

How Keras add two layers?

tf.keras.layers.add() method can add two layer?

What it do is sum the values of corresponding positions in two layers.

For example:


input_shape = (1,2,3)
import tensorflow as tf
tf.enable_eager_execution()

print("----------x1 tensor-----------")
x1 = tf.random.uniform(input_shape, maxval=10, dtype=tf.dtypes.int32)
tf.print(x1);
print("----------x2 tensor-----------")
x2 = tf.random.uniform(input_shape, maxval=10, dtype=tf.dtypes.int32)
tf.print(x2);
print("----------add 2 tensors-----------")
y = tf.keras.layers.add([x1,x2])
tf.print(y);

Output: ———-x1 tensor———– [[[7 6 1] [5 7 2]]] ———-x2 tensor———– [[[0 7 8] [2 9 6]]] ———-add 2 tensors———– [[[7 13 9] [7 16 8]]]

如何计算RNN和LSTM的参数数量？

Mon, 23 Nov 2020 20:29:20 +0800

如何计算RNN和LSTM的参数数量？

Environment:

python version: 3.7.4
pip version: 19.0.3
numpy version:1.19.4
matplotlib version:3.3.3
tensorflow version:1.14.0
keras version:2.1.5

代码如下:

from keras.layers import SimpleRNN
from keras.models import Model
from keras import Input

inputs = Input((None, 5))
simple_rnn = SimpleRNN(4)

output = simple_rnn(inputs) # The output has shape `[32, 4]`.
model = Model(inputs,output)
model.summary()

Output:

_________________________________________________________________
Layer (type) Output Shape Param # 
=================================================================
input_4 (InputLayer) (None, None, 5) 0 
_________________________________________________________________
simple_rnn_1 (SimpleRNN) (None, 4) 40 
=================================================================
Total params: 40
Trainable params: 40
Non-trainable params: 0
_________________________________________________________________

这里的simple_rnn_1中的param为40是怎么计算的呢？

创建一个简单的RNN网络

Mon, 23 Nov 2020 19:57:20 +0800

创建一个简单的RNN网络

Environment:

python version: 3.7.4
pip version: 19.0.3
numpy version:1.19.4
matplotlib version:3.3.3
tensorflow version:1.14.0
keras version:2.1.5

代码如下：

import keras
from keras import backend as K
from keras.layers import RNN
class MinimalRNNCell(keras.layers.Layer):

	def __init__(self, units,use_bias = True, **kwargs):
		self.units = units
		self.state_size = units
		self.use_bias = use_bias
		super(MinimalRNNCell, self).__init__(**kwargs)

	def build(self, input_shape):
		self.kernel = self.add_weight(shape=(input_shape[-1], self.units), # 添加kernel
										initializer='uniform',
										name='kernel')
		self.recurrent_kernel = self.add_weight(# 添加循环层kernel
			shape=(self.units, self.units),
			initializer='uniform',
			name='recurrent_kernel')

		if self.use_bias:
			self.bias = self.add_weight( # 添加bias
				shape=(self.units,),
				name='bias',
				initializer='uniform',)
		else:
			self.bias = None

		self.built = True

	def call(self, inputs, states):
		prev_output = states[0]
		h = K.dot(inputs, self.kernel)
		output = h + K.dot(prev_output, self.recurrent_kernel)
		return output, [output]


# Let's use this cell in a RNN layer:

cell = MinimalRNNCell(32)
x = keras.Input((None, 5))
layer = RNN(cell)
y = layer(x)

model = keras.Model(x,y)
model.summary()

Output:

如何计算一个BatchNormalization的参数？

Tue, 17 Nov 2020 19:48:00 +0800

如何计算一个BatchNormalization的参数？

# Environment：
# OS			macOS Catalina 10.15.6
# python 		3.7
# pip 			20.1.1
# tensorflow	1.14.0
# Keras 		2.1.5

from keras.models import Sequential
from keras.layers import Conv2D,BatchNormalization
model = Sequential();
# conv2d + max pooling
model.add(
	Conv2D(96, 
		kernel_size = (11,11), 
		strides=(4, 4), 
		padding="valid", 
		input_shape=(224,224,3),
		activation="relu")
	); # output 55 * 55 * 96 

# batchNormalization ! 
model.add(BatchNormalization()) # output
model.summary();

output:

双线插值是什么？

Sun, 15 Nov 2020 22:56:20 +0800

双线插值是什么？

图像处理中，有时我们需要放大图片，比如原来图片宽高是300*300px，如果要在500*500的屏幕上展示，这时一种方法就是把图片直接拉大到500*500，但会发现图像变得模糊了，有没有什么办法可以放大图像而又不会让图像过于模糊呢？

如何计算一个卷积层的参数？

Sun, 25 Oct 2020 20:48:00 +0800

如何计算一个卷积参数？

在计算卷积参数前，我们先来看几个小问题。

1.怎么判断一个卷积核有多少通道？

一个卷积核的通道数=前一层的通道数； 比如前一层是64x64x3的图像，那卷积核的通道数就是3层。

2.怎么理解卷积核数量和卷积核通道数？

如果把一个卷积核比喻成一本书，那卷积核的通道数就是一本书的页数。

如何计算全连接神经元参数

Thu, 22 Oct 2020 07:56:20 +0800

如何计算全连接神经元参数？

模型源码为：

from tensorflow.keras import models
from tensorflow.keras import layers
network = models.Sequential()
network.add(layers.Dense(504, activation='relu', input_shape=(504,)))
network.add(layers.Dense(11, activation='softmax'))
network.summary()

输出：

Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param # 
=================================================================
dense (Dense) (None, 504) 254520 
_________________________________________________________________
dense_1 (Dense) (None, 11) 5555 
=================================================================
Total params: 260,075
Trainable params: 260,075
Non-trainable params: 0
_________________________________________________________________

在第一行中，dense中的254520是怎么计算呢？其计算方式如下：

Tensorflow 保存和加载model

Wed, 21 Oct 2020 20:56:20 +0800

Tensorflow 保存和加载model

保存model的代码:

import tensorflow as tf
save_model_path 	= "/save_model" # 保存的文件夹路径
network.save(save_model_path);

保存的目录格式如下，期中saved_model.pb是主要的文件：

save_model
	-- assets
	-- variables
		-- variables.data-00000-of-00001
		-- variables.index
	-- saved_model.pb

加载model如下：

Some notes on Convolution Course

Thu, 21 May 2020 15:18:20 +0800

Some notes on Convolution course

What is padding?

Padding is to add some pixels to the border of the original image, such as a 6*6 image will become a 8*8 image if we add a pixel to its border.

valid convolution vs same convolution.

Valid convolution is on padding that means the actual pixels of the output image after we convole original image with filter.

Same convolution means adding padding so that the output image has the same size as its input image.

Terms in machine learning

Mon, 01 Jan 0001 00:00:00 +0000

Terms in machine learning

FLOPS

FLOPS=Floating point operation per seconds
FLOPs=Floating point operations

REFERNECD: what-is-flops-in-field-of-deep-learning