code stringlengths 17 6.64M |
|---|
def load_gan(gan_path, n_gan_images):
return get_gan_data(n_gan_images)
|
def get_gan_data(n_gan_images):
images = dict()
labels = []
for i in range(N_CLUSTER):
f = open(os.path.join(dataset.cluster_path(), ('gan%s.list' % i)), 'r')
tmp_labels = np.zeros(shape=dataset.n_classe(), dtype=np.int32)
for line in f:
lbl = line.strip()
t... |
def copyfolder(src, dst):
files = os.listdir(src)
if (not os.path.isdir(dst)):
os.mkdir(dst)
for tt in files:
copyfile(((src + '/') + tt), ((dst + '/') + tt))
|
class dcganDataset(Dataset):
def __init__(self, root, transform=None, targte_transform=None):
super(dcganDataset, self).__init__()
self.image_dir = os.path.join(opt.data_dir, root)
self.samples = []
self.img_label = []
self.img_flag = []
self.transform = transform
... |
class SLSloss(nn.Module):
def __init__(self):
super(SLSloss, self).__init__()
def forward(self, input, target, flg):
if (input.dim() > 2):
input = input.view(input.size(0), input.size(1), (- 1))
input = input.transpose(1, 2)
input = input.contiguous().view... |
def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
since = time.time()
best_model_wts = model.state_dict()
best_acc = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, (num_epochs - 1)))
print(('-' * 10))
for phase in ['train', 'val']:
... |
def save_network(network, epoch_label):
save_filename = ('net_%s.pth' % epoch_label)
save_path = os.path.join('./model', name, save_filename)
torch.save(network.cpu().state_dict(), save_path)
if torch.cuda.is_available:
network.cuda(gpu_ids[0])
|
def load_network(network):
save_path = os.path.join('./model', name, ('net_%s.pth' % opt.which_epoch))
network.load_state_dict(torch.load(save_path))
return network
|
def fliplr(img):
'flip horizontal'
inv_idx = torch.arange((img.size(3) - 1), (- 1), (- 1)).long()
img_flip = img.index_select(3, inv_idx)
return img_flip
|
def extract_feature(model, dataloaders):
features = torch.FloatTensor()
count = 0
for data in dataloaders:
(img, label) = data
(n, c, h, w) = img.size()
count += n
print(count)
if opt.use_dense:
ff = torch.FloatTensor(n, 1024).zero_()
else:
... |
def get_id(img_path):
camera_id = []
labels = []
for (path, v) in img_path:
filename = path.split('/')[(- 1)]
label = filename[0:4]
camera = filename.split('c')[1]
if (label[0:2] == '-1'):
labels.append((- 1))
else:
labels.append(int(label))
... |
def test(model, queryloader, galleryloader, use_gpu, ranks=[1, 5, 10, 20]):
batch_time = AverageMeter()
model.eval()
with torch.no_grad():
(qf, q_pids, q_camids) = ([], [], [])
for (batch_idx, (imgs, pids, camids)) in enumerate(queryloader):
if use_gpu:
imgs = i... |
def load_network(network):
save_path = os.path.join(opt.model_path)
network.load_state_dict(torch.load(save_path))
return network
|
def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
since = time.time()
best_model_wts = model.state_dict()
best_acc = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, (num_epochs - 1)))
print(('-' * 10))
for phase in ['train', 'val']:
... |
def save_network(network, epoch_label):
save_filename = ('net_%s.pth' % epoch_label)
save_path = os.path.join('./model', name, save_filename)
torch.save(network.cpu().state_dict(), save_path)
if torch.cuda.is_available:
network.cuda(gpu_ids[0])
|
def get_gan_data(generated_size, n_clusters=3, generated_dir=None):
assert (generated_dir is not None)
labels = []
for i in range(n_clusters):
f = open(os.path.join('/home/paul/clustering', ('gan%s.list' % i)), 'r')
tmp_labels = np.zeros(shape=n_classes, dtype=np.float)
for line in... |
class AverageMeter(object):
'Computes and stores the average and current value.\n\n Code imported from https://github.com/pytorch/examples/blob/master/imagenet/main.py#L247-L262\n '
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.... |
def read_json(fpath):
with open(fpath, 'r') as f:
obj = json.load(f)
return obj
|
def mkdir_if_missing(directory):
if (not os.path.exists(directory)):
os.makedirs(directory)
|
def write_json(obj, fpath):
mkdir_if_missing(os.path.dirname(fpath))
with open(fpath, 'w') as f:
json.dump(obj, f, indent=4, separators=(',', ': '))
|
def Conv(incoming, num_filters, filter_size=3, stride=(1, 1), pad='same', W=lasagne.init.HeNormal(), b=None, nonlinearity=lasagne.nonlinearities.rectify, **kwargs):
'\n Overrides the default parameters for ConvLayer\n '
ensure_set_name('conv', kwargs)
return ConvLayer(incoming, num_filters, filter_s... |
class ConvPrelu(Layer):
def __init__(self, incoming, num_filters, filter_size=3, stride=(1, 1), pad='same', W=lasagne.init.HeNormal(), b=None, **kwargs):
ensure_set_name('conv_prelu', kwargs)
super(ConvPrelu, self).__init__(incoming, **kwargs)
self.conv = Conv(incoming, num_filters, filte... |
class ConvAggr(Layer):
def __init__(self, incoming, num_channels, filter_size=3, stride=(1, 1), pad='same', W=lasagne.init.HeNormal(), b=None, **kwargs):
ensure_set_name('conv_aggr', kwargs)
super(ConvAggr, self).__init__(incoming, **kwargs)
self.conv = Conv(incoming, num_channels, filter... |
def Conv3D(incoming, num_filters, filter_size=3, stride=(1, 1, 1), pad='same', W=lasagne.init.HeNormal(), b=lasagne.init.Constant(), nonlinearity=lasagne.nonlinearities.rectify, **kwargs):
'\n Overrides the default parameters for Conv3DLayer\n '
ensure_set_name('conv3d', kwargs)
return Conv3DLayer(i... |
class Conv3DPrelu(Layer):
def __init__(self, incoming, num_filters, filter_size=3, stride=(1, 1, 1), pad='same', W=lasagne.init.HeNormal(), b=None, **kwargs):
ensure_set_name('conv3d_prelu', kwargs)
super(Conv3DPrelu, self).__init__(incoming, **kwargs)
self.conv = Conv3D(incoming, num_fil... |
class Conv3DAggr(Layer):
def __init__(self, incoming, num_channels, filter_size=3, stride=(1, 1, 1), pad='same', W=lasagne.init.HeNormal(), b=None, **kwargs):
ensure_set_name('conv3d_aggr', kwargs)
super(Conv3DAggr, self).__init__(incoming, **kwargs)
self.conv = Conv3D(incoming, num_chann... |
class DataConsistencyLayer(MergeLayer):
'\n Data consistency layer\n '
def __init__(self, incomings, inv_noise_level=None, **kwargs):
super(DataConsistencyLayer, self).__init__(incomings, **kwargs)
self.inv_noise_level = inv_noise_level
def get_output_for(self, inputs, **kwargs):
... |
class DataConsistencyWithMaskLayer(MergeLayer):
'\n Data consistency layer\n '
def __init__(self, incomings, inv_noise_level=None, **kwargs):
super(DataConsistencyWithMaskLayer, self).__init__(incomings, **kwargs)
self.inv_noise_level = inv_noise_level
def get_output_for(self, inpu... |
class DCLayer(MergeLayer):
'\n Data consistency layer\n '
def __init__(self, incomings, data_shape, inv_noise_level=None, **kwargs):
if ('name' not in kwargs):
kwargs['name'] = 'dc'
super(DCLayer, self).__init__(incomings, **kwargs)
self.inv_noise_level = inv_noise_l... |
def ensure_set_name(default_name, kwargs):
"Ensure that the parameters contain names. Be careful, kwargs need to be\n passed as a dictionary here\n\n Parameters\n ----------\n default_name: string\n default name to set if neither name or pr is present, or if name is not\n present but pr ... |
def get_dc_input_layers(shape):
'\n Creates input layer for the CNN. Works for 2D and 3D input.\n\n Returns\n -------\n net: Ordered Dictionary\n net config with 3 entries: input, kspace_input, mask.\n '
if (len(shape) > 4):
input_var = tensor5('input_var')
kspace_input_va... |
def roll_and_sum(prior_result, orig):
res = (prior_result + orig)
res = T.roll(res, 1, axis=(- 1))
return res
|
class KspaceFillNeighbourLayer(MergeLayer):
'\n k-space fill layer - The input data is assumed to be in k-space grid.\n\n The input data is assumed to be in k-space grid.\n This layer should be invoked from AverageInKspaceLayer\n '
def __init__(self, incomings, frame_dist=range(5), divide_by_n=Fa... |
class KspaceFillNeighbourLayer_Clipped(MergeLayer):
'\n k-space fill layer with clipping at the edge.\n\n The input data is assumed to be in k-space grid.\n This layer should be invoked from AverageInKspaceLayer\n '
def __init__(self, incomings, nt, frame_dist=range(5), divide_by_n=False, **kwarg... |
class AverageInKspaceLayer(MergeLayer):
'\n Average-in-k-space layer\n\n First transforms the representation in Fourier domain,\n then performs averaging along temporal axis, then transforms back to image\n domain. Works only for 5D tensor (see parameter descriptions).\n\n\n Parameters\n -------... |
class PoolNDLayer(Layer):
"\n ND pooling layer\n\n Performs ND mean or max-pooling over the trailing axes\n of a ND input tensor.\n\n Parameters\n ----------\n incoming : a :class:`Layer` instance or tuple\n The layer feeding into this layer, or the expected input shape.\n\n pool_size ... |
class Upscale3DLayer(Layer):
'\n 3D upscaling layer\n Performs 3D upscaling over the two trailing axes of a 4D input tensor.\n Parameters\n ----------\n incoming : a :class:`Layer` instance or tuple\n The layer feeding into this layer, or the expected input shape.\n scale_factor : integer... |
class IdLayer(Layer):
def get_output_for(self, input, **kwargs):
return input
|
class SumLayer(Layer):
def get_output_for(self, input, **kwargs):
return input.sum(axis=(- 1))
def get_output_shape_for(self, input_shape):
return input_shape[:(- 1)]
|
class SHLULayer(Layer):
def get_output_for(self, input, **kwargs):
return (T.sgn(input) * T.maximum((input - 1), 0))
|
class ResidualLayer(lasagne.layers.ElemwiseSumLayer):
'\n Residual Layer, which just wraps around ElemwiseSumLayer\n '
def __init__(self, incomings, **kwargs):
ensure_set_name('res', kwargs)
super(ResidualLayer, self).__init__(incomings, **kwargs)
input_names = []
for l ... |
def cascade_resnet(pr, net, input_layer, n=5, nf=64, b=lasagne.init.Constant, **kwargs):
shape = lasagne.layers.get_output_shape(input_layer)
n_channel = shape[1]
net[(pr + 'conv1')] = l.Conv(input_layer, nf, 3, b=b(), name=(pr + 'conv1'))
for i in xrange(2, n):
net[(pr + ('conv%d' % i))] = l.... |
def cascade_resnet_3d_avg(pr, net, input_layer, n=5, nf=64, b=lasagne.init.Constant, frame_dist=range(5), **kwargs):
shape = lasagne.layers.get_output_shape(input_layer)
n_channel = shape[1]
divide_by_n = (kwargs['cascade_i'] != 0)
k = (3, 3, 3)
net[(pr + 'kavg')] = l.AverageInKspaceLayer([input_l... |
def build_cascade_cnn_from_list(shape, net_meta, lmda=None):
'\n Create iterative network with more flexibility\n\n net_meta: [(model1, cascade1_n),(model2, cascade2_n),....(modelm, cascadem_n),]\n '
if (not net_meta):
raise
net = OrderedDict()
(input_layer, kspace_input_layer, mask_l... |
def build_d2_c2(shape):
def cascade_d2(pr, net, input_layer, **kwargs):
return cascade_resnet(pr, net, input_layer, n=2)
return build_cascade_cnn_from_list(shape, [(cascade_d2, 2)])
|
def build_d5_c5(shape):
return build_cascade_cnn_from_list(shape, [(cascade_resnet, 5)])
|
def build_d2_c2_s(shape):
def cascade_d2(pr, net, input_layer, **kwargs):
return cascade_resnet_3d_avg(pr, net, input_layer, n=2, nf=16, frame_dist=range(2), **kwargs)
return build_cascade_cnn_from_list(shape, [(cascade_d2, 2)])
|
def build_d5_c10_s(shape):
return build_cascade_cnn_from_list(shape, [(cascade_resnet_3d_avg, 10)])
|
class FFTOp(gof.Op):
__props__ = ()
def output_type(self, inp):
return T.TensorType(inp.dtype, broadcastable=([False] * inp.type.ndim))
def make_node(self, a, s=None):
a = T.as_tensor_variable(a)
if (a.ndim < 3):
raise TypeError((('%s: input must have dimension >= 3, ... |
class IFFTOp(gof.Op):
__props__ = ()
def output_type(self, inp):
return T.TensorType(inp.dtype, broadcastable=([False] * inp.type.ndim))
def make_node(self, a, s=None):
a = T.as_tensor_variable(a)
if (a.ndim < 3):
raise TypeError((('%s: input must have dimension >= 3,... |
def fft(inp, norm=None):
"\n Performs the fast Fourier transform of a complex-valued input simulated by R^2.\n\n The input must be a real-valued variable of dimensions (m, ..., n, 2).\n It performs FFTs of size n along the last axis. \n\n The output is a tensor of dimensions (m, ..., n, 2).\n The r... |
def ifft(inp, norm=None):
"\n Performs the inverse fast Fourier Transform with complex-valued input simulated by R^2.\n\n The input is a variable of dimensions (m, ..., n, 2)\n The real and imaginary parts are stored as a\n pair of float arrays.\n\n The output is a real-valued variable of dimension... |
def _unitary(norm):
if (norm not in (None, 'ortho', 'no_norm')):
raise ValueError(("Invalid value %s for norm, must be None, 'ortho' or 'no norm'" % norm))
return norm
|
class FFT2Op(gof.Op):
__props__ = ()
def output_type(self, inp):
return T.TensorType(inp.dtype, broadcastable=([False] * inp.type.ndim))
def make_node(self, a, s=None):
a = T.as_tensor_variable(a)
if (a.ndim < 4):
raise TypeError((('%s: input must have dimension >= 4,... |
class IFFT2Op(gof.Op):
__props__ = ()
def output_type(self, inp):
return T.TensorType(inp.dtype, broadcastable=([False] * inp.type.ndim))
def make_node(self, a, s=None):
a = T.as_tensor_variable(a)
if (a.ndim < 4):
raise TypeError((('%s: input must have dimension >= 4... |
def fft2(inp, norm=None):
"\n Performs the fast Fourier transform of a complex-valued input simulated by R^2.\n\n The input must be a real-valued variable of dimensions (m, ..., n, 2).\n It performs FFT2s of size n along the last axis. \n\n The output is a tensor of dimensions (m, ..., n, 2).\n The... |
def ifft2(inp, norm=None):
"\n Performs the inverse fast Fourier Transform with complex-valued input simulated by R^2.\n\n The input is a variable of dimensions (m, ..., n, 2)\n The real and imaginary parts are stored as a\n pair of float arrays.\n\n The output is a real-valued variable of dimensio... |
def _unitary(norm):
if (norm not in (None, 'ortho', 'no_norm')):
raise ValueError(("Invalid value %s for norm, must be None, 'ortho' or 'no norm'" % norm))
return norm
|
class FFTSHIFTOp(gof.Op):
__props__ = ()
def output_type(self, inp):
return T.TensorType(inp.dtype, broadcastable=([False] * inp.type.ndim))
def make_node(self, x, axes=None):
x = T.as_tensor_variable(x)
if (x.ndim < 2):
raise TypeError((('%s: input must have dimensio... |
class IFFTSHIFTOp(gof.Op):
__props__ = ()
def output_type(self, inp):
return T.TensorType(inp.dtype, broadcastable=([False] * inp.type.ndim))
def make_node(self, x, axes=None):
x = T.as_tensor_variable(x)
if (x.ndim < 2):
raise TypeError((('%s: input must have dimensi... |
def fftshift(x, axes=None):
'\n Performs np.fft.fftshift. Gradient is implemented as ifftshift\n\n Parameters\n ----------\n x : array_like\n Input array.\n axes : int or shape tuple, optional\n Axes over which to calculate. Defaults to None, which shifts all axes.\n\n Returns\n ... |
def ifftshift(x, axes=None):
'\n Performs np.fft.ifftshift. Gradient is implemented as fftshift\n\n Parameters\n ----------\n x : array_like\n Input array.\n axes : int or shape tuple, optional\n Axes over which to calculate. Defaults to None, which shifts all axes.\n\n Returns\n ... |
class CuFFTOp(Op):
__props__ = ()
def output_type(self, inp):
return GpuArrayType(inp.dtype, broadcastable=([False] * inp.type.ndim), context_name=inp.type.context_name)
def make_node(self, inp, s=None):
if (not scikits_cuda_available):
raise RuntimeError('skcuda is needed fo... |
class CuIFFTOp(Op):
__props__ = ()
def output_type(self, inp):
return GpuArrayType(inp.dtype, broadcastable=([False] * inp.type.ndim), context_name=inp.type.context_name)
def make_node(self, inp, s=None):
if (not scikits_cuda_available):
raise RuntimeError('skcuda is needed f... |
def cufft(inp, norm=None):
"\n Performs the fast Fourier transform of a real-valued input on the GPU.\n\n The input must be a real-valued float32 variable of dimensions (m, ..., n, 2).\n It performs FFTs of size (..., n) on m batches.\n\n The output is a GpuArray of dimensions (m, ..., n, 2). The seco... |
def cuifft(inp, norm=None, is_odd=False):
"\n Performs the inverse fast Fourier Transform with real-valued output on the GPU.\n\n The input is a variable of dimensions (m, ..., n, 2) with\n type float32 representing the non-trivial elements of m\n real-valued Fourier transforms of initial size (..., n... |
def _unitary(norm):
if (norm not in (None, 'ortho', 'no_norm')):
raise ValueError(("Invalid value %s for norm, must be None, 'ortho' or 'no norm'" % norm))
return norm
|
class CuFFT2Op(Op):
__props__ = ()
def output_type(self, inp):
return GpuArrayType(inp.dtype, broadcastable=([False] * inp.type.ndim), context_name=inp.type.context_name)
def make_node(self, inp, s=None):
if (not scikits_cuda_available):
raise RuntimeError('skcuda is needed f... |
class CuIFFT2Op(Op):
__props__ = ()
def output_type(self, inp):
return GpuArrayType(inp.dtype, broadcastable=([False] * inp.type.ndim), context_name=inp.type.context_name)
def make_node(self, inp, s=None):
if (not scikits_cuda_available):
raise RuntimeError('skcuda is needed ... |
def cufft2(inp, norm=None):
"\n Performs the 2D fast Fourier transform of a simulated complex-valued input on the GPU.\n\n The input must be a real-valued float32 variable of dimensions (m, ..., nx, ny, 2).\n It performs 2D FFTs of size (..., nx, ny) on m batches.\n\n The output is a GpuArray of dimen... |
def cuifft2(inp, norm=None):
"\n Performs the 2D inverse fast Fourier transform of a simulated complex-valued input on the GPU.\n\n The input must be a real-valued float32 variable of dimensions (m, ..., nx, ny, 2).\n It performs 2D IFFTs of size (..., nx, ny) on m batches.\n\n The output is a GpuArra... |
def _unitary(norm):
if (norm not in (None, 'ortho', 'no_norm')):
raise ValueError(("Invalid value %s for norm, must be None, 'ortho' or 'no norm'" % norm))
return norm
|
class CuRFFTOp(Op):
__props__ = ()
def output_type(self, inp):
return GpuArrayType(inp.dtype, broadcastable=([False] * (inp.type.ndim + 1)), context_name=inp.type.context_name)
def make_node(self, inp, s=None):
if (not scikits_cuda_available):
raise RuntimeError('skcuda is ne... |
class CuIRFFTOp(Op):
__props__ = ()
def output_type(self, inp):
return GpuArrayType(inp.dtype, broadcastable=([False] * (inp.type.ndim - 1)), context_name=inp.type.context_name)
def make_node(self, inp, s=None):
if (not scikits_cuda_available):
raise RuntimeError('skcuda is n... |
def curfft(inp, norm=None):
"\n Performs the fast Fourier transform of a real-valued input on the GPU.\n\n The input must be a real-valued float32 variable of dimensions (m, ..., n).\n It performs FFTs of size (..., n) on m batches.\n\n The output is a GpuArray of dimensions (m, ..., n//2+1, 2). The s... |
def cuirfft(inp, norm=None, is_odd=False):
"\n Performs the inverse fast Fourier Transform with real-valued output on the GPU.\n\n The input is a variable of dimensions (m, ..., n//2+1, 2) with\n type float32 representing the non-trivial elements of m\n real-valued Fourier transforms of initial size (... |
def _unitary(norm):
if (norm not in (None, 'ortho', 'no_norm')):
raise ValueError(("Invalid value %s for norm, must be None, 'ortho' or 'no norm'" % norm))
return norm
|
def tensor5(name=None, dtype=None):
if (dtype is None):
dtype = theano.config.floatX
type = T.TensorType(dtype, ((False,) * 5))
return type(name)
|
def prep_input(im, acc=4):
'Undersample the batch, then reformat them into what the network accepts.\n\n Parameters\n ----------\n gauss_ivar: float - controls the undersampling rate.\n higher the value, more undersampling\n '
mask = cs.cartesian_mask(im.shape, acc, sample_n... |
def iterate_minibatch(data, batch_size, shuffle=True):
n = len(data)
if shuffle:
data = np.random.permutation(data)
for i in xrange(0, n, batch_size):
(yield data[i:(i + batch_size)])
|
def create_dummy_data():
'\n Creates dummy dataset from one knee subject for demo.\n In practice, one should take much bigger dataset,\n as well as train & test should have similar distribution.\n\n Source: http://mridata.org/\n '
data = loadmat(join(project_root, './data/lustig_knee_p2.mat'))[... |
def compile_fn(network, net_config, args):
'\n Create Training function and validation function\n '
base_lr = float(args.lr[0])
l2 = float(args.l2[0])
input_var = net_config['input'].input_var
mask_var = net_config['mask'].input_var
kspace_var = net_config['kspace_input'].input_var
t... |
def mse(x, y):
return np.mean((np.abs((x - y)) ** 2))
|
def psnr(x, y):
'\n Measures the PSNR of recon w.r.t x.\n Image must be of either integer (0, 256) or float value (0,1)\n :param x: [m,n]\n :param y: [m,n]\n :return:\n '
assert (x.shape == y.shape)
assert ((x.dtype == y.dtype) or (np.issubdtype(x.dtype, np.float) and np.issubdtype(y.dty... |
def complex_psnr(x, y, peak='normalized'):
"\n x: reference image\n y: reconstructed image\n peak: normalised or max\n\n Notice that ``abs'' squares\n Be careful with the order, since peak intensity is taken from the reference\n image (taking from reconstruction yields a different value).\n\n ... |
def fftc(x, axis=(- 1), norm='ortho'):
' expect x as m*n matrix '
return fftshift(fft(ifftshift(x, axes=axis), axis=axis, norm=norm), axes=axis)
|
def ifftc(x, axis=(- 1), norm='ortho'):
' expect x as m*n matrix '
return fftshift(ifft(ifftshift(x, axes=axis), axis=axis, norm=norm), axes=axis)
|
def fft2c(x):
'\n Centered fft\n Note: fft2 applies fft to last 2 axes by default\n :param x: 2D onwards. e.g: if its 3d, x.shape = (n,row,col). 4d:x.shape = (n,slice,row,col)\n :return:\n '
axes = ((- 2), (- 1))
res = fftshift(fft2(ifftshift(x, axes=axes), norm='ortho'), axes=axes)
ret... |
def ifft2c(x):
'\n Centered ifft\n Note: fft2 applies fft to last 2 axes by default\n :param x: 2D onwards. e.g: if its 3d, x.shape = (n,row,col). 4d:x.shape = (n,slice,row,col)\n :return:\n '
axes = ((- 2), (- 1))
res = fftshift(ifft2(ifftshift(x, axes=axes), norm='ortho'), axes=axes)
... |
def fourier_matrix(rows, cols):
'\n parameters:\n rows: number or rows\n cols: number of columns\n\n return unitary (rows x cols) fourier matrix\n '
col_range = np.arange(cols)
row_range = np.arange(rows)
scale = (1 / np.sqrt(cols))
coeffs = np.outer(row_range, col_range)
fourie... |
def inverse_fourier_matrix(rows, cols):
return np.array(np.matrix(fourier_matrix(rows, cols)).getH())
|
def flip(m, axis):
'\n ==== > Only in numpy 1.12 < =====\n\n Reverse the order of elements in an array along the given axis.\n The shape of the array is preserved, but the elements are reordered.\n .. versionadded:: 1.12.0\n Parameters\n ----------\n m : array_like\n Input array.\n ... |
def rot90_nd(x, axes=((- 2), (- 1)), k=1):
'Rotates selected axes'
def flipud(x):
return flip(x, axes[0])
def fliplr(x):
return flip(x, axes[1])
x = np.asanyarray(x)
if (x.ndim < 2):
raise ValueError('Input must >= 2-d.')
k = (k % 4)
if (k == 0):
return x
... |
def data_loader(file_name='data/google.csv', seq_len=7, missing_rate=0.2):
'Load complete data and introduce missingness.\n \n Args:\n - file_name: the location of file to be loaded\n - seq_len: sequence length\n - missing_rate: rate of missing data to be introduced\n \n Returns:\n - x: data wit... |
def main(args):
'MRNN main function.\n \n Args:\n - file_name: dataset file name\n - seq_len: sequence length of time-series data\n - missing_rate: the rate of introduced missingness\n - h_dim: hidden state dimensions\n - batch_size: the number of samples in mini batch\n - iteration: the numbe... |
def MinMaxScaler(data):
'Normalization tool: Min Max Scaler.\n \n Args:\n - data: raw input data\n \n Returns:\n - normalized_data: minmax normalized data\n - norm_parameters: normalization parameters for rescaling if needed\n '
min_val = np.min(data, axis=0)
data = (data - min_val)
ma... |
def imputation_performance(ori_x, imputed_x, m, metric_name):
'Performance metrics for imputation.\n \n Args:\n - ori_x: original complete data (without missing values)\n - imputed_x: imputed data from incomplete data\n - m: observation indicator\n - metric_name: mae, mse, or rmse\n \n Returns:\... |
def define_classification_model():
' Select and define the model you will use for the classifier. \n '
if (config['model_type'] == 'linearSVM'):
return LinearSVC(C=1)
elif (config['model_type'] == 'SVM'):
return SVC(C=1, kernel='rbf', gamma='scale')
elif (config['model_type'] == 'kN... |
def extract_vggish_features(paths, path2gt, model):
'Extracts VGGish features and their corresponding ground_truth and identifiers (the path).\n\n VGGish features are extracted from non-overlapping audio patches of 0.96 seconds, \n where each audio patch covers 64 mel bands and 96 frames of 10 ms each... |
def extract_other_features(paths, path2gt, model_type):
'Extracts MusiCNN or OpenL3 features and their corresponding ground_truth and identifiers (the path).\n\n OpenL3 features are extracted from non-overlapping audio patches of 1 second, \n where each audio patch covers 128 mel bands.\n\n Musi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.