Making a 3D diagonal matrix in Python

Making a 3D diagonal matrix in Python - python

I would like to create 3D diagonal matrices. I already succeded to create one with numpy routine numpy.fill_diagonal(numpy.zeros((N, N, N)), n), however it does not allow to choose the diagonal to fill.
In other words, I would like to find the 3D generalization of this numpy routine : https://numpy.org/doc/stable/reference/generated/numpy.diag.html. Thank you.

Well instead of using np.diag to fill a semi diagonal you can do it manually like this:
N = 4
arr = np.zeros((N, N))
i = np.arange(N-1)
arr[i,i+1] = 1
array([[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.],
[0., 0., 0., 0.]])
And it has the advantage to generalize to 3d arrays.
arr = np.zeros((N, N, N))
i = np.arange(N-1)
arr[i,i,i+1] = 1
array([[[0., 1., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 1.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])

Related

Create an identity matrix with scalar in python

This creates an identity matrix.
np.identity(3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
But what if I want to multiply with 3I like this?
array([[3., 0., 0.],
[0., 3., 0.],
[0., 0., 3.]])

How to get the dictionary output from a generator, which outputs an array with a dictionary for custom keras image generator

I have a custom made generator to output multiple values to predict against. I'm trying to get the values to correspond to a given image, without success. Here is my output:
e(array([[[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
...,
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]],
[[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
...,
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]]], dtype=float16),
{'HourTime': array([0.3848, 0.2375], dtype=float16),
'MinTime': array([0.633, 0.862], dtype=float16),
'SecTime': array([0.967, 0.717], dtype=float16)})
My output comes from my generator here:
input_Size = 128
x,y,xrange,yrange = [136,150,47,47]
def ImGenA(directory, files_Loc, Hour, Min, Sec, batch_size):
while True:
batch_paths = imgId = np.random.choice(a = files_Loc.index, size=batch_size)
batch_input = []
batch_Hr = []
batch_Min = []
batch_Sec = []
for i in batch_paths:
img1 = cv2.imread(os.path.join(directory,files_Loc[i]))
img1 = ndimage.rotate(img1, 210)
img1 = cv2.resize (img1, (input_Size,input_Size))
batch_input+=[img1/255]
batch_Hr += [Hour[i]]
batch_Min += [Min[i]]
batch_Sec += [Sec[i]]
batch_x = np.array(batch_input, dtype='float16')
batch_y1 = np.array(batch_Hr, dtype='float16')
batch_y2 = np.array(batch_Min, dtype='float16')
batch_y3 = np.array(batch_Sec, dtype='float16')
yield( batch_x, {'HourTime' : batch_y1, 'MinTime': batch_y2, 'SecTime': batch_y3})
genA = ImGenA(directory=folder, files_Loc= train['ImageLoc'], Hour = train['HrPer'], Min = train['MinPer'], Sec = train['SecPer'],batch_size=2)
b=next(genA)
b[0][0] #provides image at position 0, but how do I find the Y output 'HourTime' at the same position?
I'm having difficulty extracting 'HourTime' from the saved output from a generator run. Sorry, I would assume it has been asked before, but I'm not sure how I can't find the answer.

It is simple, once you get it to work.
b[1]['HourTime'][0]
Provides the 'HourTime' from the dictionary for position 0.
IE. 0.3848

Adding column to higher dimension

let's assume that i have array called A
A = np.zeros((4, 3, 2))
array([[[0., 0.],
[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.],
[0., 0.]]])
and another array called B
B = np.arange(4)
array([0, 1, 2, 3])
and i want to do something like concatenation in the third dimension to got this result:
array([[[0., 0., 0.0],
[0., 0., 0.0],
[0., 0., 0.0]],
[[0., 0., 1.0],
[0., 0., 1.0],
[0., 0., 1.0]],
[[0., 0., 2.0],
[0., 0., 2.0],
[0., 0., 2.0]],
[[0., 0., 3.0],
[0., 0., 3.0],
[0., 0., 3.0]]])
i tried serval ways to do that but i didn't succeed.
who i can do that in good way not loops?

To add the extra dimension you can use np.append. You just have to get the shape correct. You can use np.repeat() to make the repeating elements:
A = np.zeros((4, 3, 2))
h, w, d = A.shape
B = np.repeat(np.arange(h), w).reshape([h, w, 1])
np.append(A, B, axis=2)
Output:
array([[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 1.],
[0., 0., 1.],
[0., 0., 1.]],
[[0., 0., 2.],
[0., 0., 2.],
[0., 0., 2.]],
[[0., 0., 3.],
[0., 0., 3.],
[0., 0., 3.]]])

We could broadcast B to the corresponding shape and use advanced indexing here and assign B broadcasted across the corresponding axes:
np.concatenate([A, np.broadcast_to(B[:,None,None], A[...,-1:].shape)], -1)
print(A)
array([[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 1.],
[0., 0., 1.],
[0., 0., 1.]],
[[0., 0., 2.],
[0., 0., 2.],
[0., 0., 2.]],
[[0., 0., 3.],
[0., 0., 3.],
[0., 0., 3.]]])

Exploding loss in pyTorch

I am trying to train a latent space model in pytorch. The model is relatively simple and just requires me to minimize my loss function but I am getting an odd error. After running for a short while the loss suddenly explodes upwards.
import numpy as np
import scipy.sparse.csgraph as csg
import torch
from torch.autograd import Variable
import torch.autograd as autograd
import matplotlib.pyplot as plt
%matplotlib inline
def cmdscale(D):
# Number of points
n = len(D)
# Centering matrix
H = np.eye(n) - np.ones((n, n))/n
# YY^T
B = -H.dot(D**2).dot(H)/2
# Diagonalize
evals, evecs = np.linalg.eigh(B)
# Sort by eigenvalue in descending order
idx = np.argsort(evals)[::-1]
evals = evals[idx]
evecs = evecs[:,idx]
# Compute the coordinates using positive-eigenvalued components only
w, = np.where(evals > 0)
L = np.diag(np.sqrt(evals[w]))
V = evecs[:,w]
Y = V.dot(L)
return Y, evals
Y = np.array([[0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 1., 1., 0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 1., 0.],
[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0.],
[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1.],
[0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 1.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
[0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 1.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 1., 0., 0., 0.]])
temp = Y[~np.all(Y == 0, axis=1)]
temp = temp[:,~np.all(Y == 0, axis=1)]
Y = temp
n = np.shape(Y)[0]
k = 2
D = csg.shortest_path(Y, directed=True)
Z = cmdscale(D)[0][:,0:k]
Z = Z - Z.mean(axis=0, keepdims=True)
tZ = autograd.Variable(torch.Tensor(Z), requires_grad=True)
B = autograd.Variable(torch.Tensor([0]), requires_grad=True)
tY = torch.autograd.Variable(torch.Tensor(Y), requires_grad=False)
#calculating pairwise euclidean distance
def distMatrix(m):
n = m.size(0)
d = m.size(1)
x = m.unsqueeze(1).expand(n, n, d)
y = m.unsqueeze(0).expand(n, n, d)
return torch.sqrt(torch.pow(x - y, 2).sum(2) + 1e-4)
def loss(tY):
d = -distMatrix(tZ)+B
sigmoidD = torch.sigmoid(d)
#removing diagonal
reduce = tY*torch.log(sigmoidD)+(1-tY)*torch.log(1-sigmoidD)
reduce[torch.eye(n).byte()] = 0
return -reduce.sum()
losses = []
learning_rate = 1e-4
l = loss(tY)
stepSize = 1000
for i in range(stepSize):
l.backward(retain_graph=True)
losses.append(float(loss(tY)))
tZ.data = tZ.data - learning_rate * tZ.grad.data
B.data = B.data - learning_rate * B.grad.data
tZ.grad.data.zero_()
B.grad.data.zero_()
plt.subplot(122)
plt.plot(losses)
plt.title('Loss')
plt.xlabel('Iteration')
plt.ylabel('loss')
plt.show()
shouldnt the loss keep going down? or atleast converge to some point? I must've done something wrong, I am new to pytorch, any hints or nudges in the right direction would be highly appreciated!

The issue was that I defined my loss
l = loss(tY)
outside of the loop that ran and updated my gradients, I am not entirely sure why it had the effect that it did, but moving the loss function definition inside of the loop solved the problem, resulting in this loss:

Solving Matrix Differential Equation in Python using Scipy/Numpy- NDSolve equivalent?

I have two numpy arrays: 9x9 and 9x1. I'd like to solve the differential equation at discrete time points, but am having trouble getting ODEInt to work. I do am unsure if I'm even doing the right thing.
With Mathematica, the equation is:
Solution = {A[t]} /. NDSolve[{A'[t] == Ab.A[t] && A[0] == A0}, {A[t]}, {t, 0, .5}, MaxSteps -> \[Infinity]];
time = 0.25;
increment = 0.05;
MA = Table[Solution, {t, 0, time, increment}];
Where Ab is the 9x9 matrix, A0 is the 9x1 matrix (initial). Here, I solve for time and life is good.
In Python implementation I have the following code which gives me the wrong answer:
from scipy.integrate import odeint
from numpy import array, dot, pi
def deriv(A, t, Ab):
return dot(Ab, A)
def MatrixBM3(k12,k21,k13,k31,k23,k32,delta1,delta2,delta3,
w1, R1, R2):
K = array([[-k21 -k23, k12, k32, 0., 0., 0., 0., 0., 0.],
[k21, -k12 - k13, k31, 0., 0., 0., 0., 0., 0.],
[k23, k13, -k31 - k32, 0., 0., 0., 0., 0., 0.],
[0., 0., 0., -k21 - k23, k12, k32, 0., 0., 0.],
[0., 0., 0., k21, -k12 - k13, k31, 0., 0., 0.],
[0., 0., 0., k23, k13, -k31 - k32, 0., 0., 0.],
[0., 0., 0., 0., 0., 0., -k21 - k23, k12, k32],
[0., 0., 0., 0., 0., 0., k21, -k12 - k13, k31],
[0., 0., 0., 0., 0., 0., k23, k13, -k31 - k32]])
Der = array([[0., 0., 0., -delta2, 0., 0., 0., 0., 0.],
[0., 0., 0., 0., -delta1, 0., 0., 0., 0.],
[0., 0., 0., 0., 0., -delta3, 0., 0., 0.],
[delta2, 0., 0., 0., 0., 0., 0., 0., 0.],
[0., delta1, 0., 0., 0., 0., 0., 0., 0.],
[0., 0., delta3, 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.]])
W = array([[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., w1, 0., 0.],
[0., 0., 0., 0., 0., 0., 0., w1, 0.],
[0., 0., 0., 0., 0., 0., 0., 0., w1],
[0., 0., 0., w1, 0., 0., 0., 0., 0.],
[0., 0., 0., 0., w1, 0., 0., 0., 0.],
[0., 0., 0., 0., 0., w1, 0., 0., 0.]])*2*pi
R = array([[-R2, 0., 0., 0., 0., 0., 0., 0., 0.],
[0., -R2, 0., 0., 0., 0., 0., 0., 0.],
[0., 0., -R2, 0., 0., 0., 0., 0., 0.],
[0., 0., 0., -R2, 0., 0., 0., 0., 0.],
[0., 0., 0., 0., -R2, 0., 0., 0., 0.],
[0., 0., 0., 0., 0., -R2, 0., 0., 0.],
[0., 0., 0., 0., 0., 0., -R1, 0., 0.],
[0., 0., 0., 0., 0., 0., 0., -R1, 0.],
[0., 0., 0., 0., 0., 0., 0., 0., -R1]])
return(K + Der + W + R)
Ab = MatrixBM3(21.218791062154633, 17653.497151475527, 40.50203461096454, 93956.36617049483, 0.0, 0.0, -646.4238856161137, 6727.748368359598, 20919.132768439955, 200.0, 2.36787, 5.39681)
A0 = array([-0.001071585381162955, -0.89153191708755708, -0.00038431516707591748, 0.0, 0.0, 0.0, 0.00054009700135979673, 0.4493470361764082, 0.00019370128872934646])
time = array([0.0,0.05,0.1,0.15,0.2,0.25])
MA = odeint(deriv, A0, time, args=(Ab,), maxsteps=2000)
Output is:
[[ -1.07158538e-003 -8.91531917e-001 -3.84315167e-004 0.00000000e+000
0.00000000e+000 0.00000000e+000 5.40097001e-004 4.49347036e-001
1.93701289e-004]
[ 3.09311322e+019 9.45061860e+022 2.35327270e+019 2.11901406e+020
1.63784238e+023 7.60569684e+019 2.29098804e+020 1.89766602e+023
8.18752241e+019]
[ 9.84409730e+042 3.00774018e+046 7.48949158e+042 6.74394343e+043
5.21257342e+046 2.42057805e+043 7.29126532e+043 6.03948436e+046
2.60574901e+043]
[ 3.13296814e+066 9.57239028e+069 2.38359473e+066 2.14631766e+067
1.65894606e+070 7.70369662e+066 2.32050753e+067 1.92211754e+070
8.29301904e+066]
[ 9.97093898e+089 3.04649506e+093 7.58599405e+089 6.83083947e+090
5.27973769e+093 2.45176732e+090 7.38521364e+090 6.11730342e+093
2.63932422e+090]
[ 3.17333659e+113 9.69573101e+116 2.41430747e+113 2.17397307e+114
1.68032166e+117 7.80295913e+113 2.35040739e+114 1.94688412e+117
8.39987500e+113]]
But the correct answer should be:
{-0.0010733126291998989, -0.8929689437405254, -0.0003849346301906338, 0., 0., 0., 0.0005366563145999495, 0.4464844718702628, 0.00019246731509531696}
{-0.000591095648651598, -0.570032546156741, -0.00023381082725213798, -0.00024790706920038567, 0.00010389803046880286, -0.00005361569187144767, 0.0003273277204077012, 0.2870035216110215, 0.00012300339326137006}
{-0.0003770535829276868, -0.364106358478121, -0.0001492324135668267, -0.0001596072774600538, -0.0011479989178276948, -0.000034744485507007025, 0.00020965172928479557, 0.18378613639965447, 0.00007876820247280559}
{-0.00024100792803807562, -0.23298939195213314, -0.00009543704274825206, -0.00010271831380730501, -0.0013205519868311284, -0.000022472380871477824, 0.00013326471695185768, 0.11685506361394844, 0.00005008078740423007}
{-0.00015437993249587976, -0.1491438843823813, -0.00006111736454518403, -0.00006545797627466387, -0.0005705018939767294, -0.000014272382451480663, 0.00008455890984798549, 0.0741820536557778, 0.00003179071165818503}
{-0.00009882799610556456, -0.09529950309336405, -0.00003909275555213336, -0.00004138741286392128, 0.00006303116741431477, -8.944610716890746*^-6, 0.00005406263888971806, 0.04743157303933772, 0.00002032674776723143}
Can anyone point me to what I may be doing wrong?

In the call to odeint, try changing tuple(array[Ab]) to (array(Ab),), or even just (Ab,). That is, use
MA = odeint(deriv, A0, time, (Ab,))
Without seeing how you defined A0 and Ab, I can't be sure that this will fix the problem, but the following variation of your code will work. I used a 3x3 array instead of 9x9.
import numpy as np
from scipy.integrate import odeint
def deriv(A, t, Ab):
return np.dot(Ab, A)
Ab = np.array([[-0.25, 0, 0],
[ 0.25, -0.2, 0],
[ 0, 0.2, -0.1]])
time = np.linspace(0, 25, 101)
A0 = np.array([10, 20, 30])
MA = odeint(deriv, A0, time, args=(Ab,))

Develop Reference

Python is a programming language that lets you work quickly and integrate systems more effectively.

Making a 3D diagonal matrix in Python - python

Related

Create an identity matrix with scalar in python

How to get the dictionary output from a generator, which outputs an array with a dictionary for custom keras image generator

Adding column to higher dimension

Exploding loss in pyTorch

Solving Matrix Differential Equation in Python using Scipy/Numpy- NDSolve equivalent?

Categories

Resources