Convert integer to pytorch tensor of binary bits - pytorch
Given an number and an encoding length, how can I convert the number to its binary representation as a tensor?
Eg, given the number 6 and width 8, how can I obtain the tensor:
(0, 0, 0, 0, 0, 1, 1, 0)
def binary(x, bits):
mask = 2**torch.arange(bits).to(x.device, x.dtype)
return x.unsqueeze(-1).bitwise_and(mask).ne(0).byte()
If you wanna reverse the order of bits, use it with torch.arange(bits-1,-1,-1) instead.
Tiana's answer was a good one. BTW, to convert Tiana's 2-base result back to 10-base numbers, one can do like this:
import torch
import numpy as np
def dec2bin(x, bits):
# mask = 2 ** torch.arange(bits).to(x.device, x.dtype)
mask = 2 ** torch.arange(bits - 1, -1, -1).to(x.device, x.dtype)
return x.unsqueeze(-1).bitwise_and(mask).ne(0).float()
def bin2dec(b, bits):
mask = 2 ** torch.arange(bits - 1, -1, -1).to(b.device, b.dtype)
return torch.sum(mask * b, -1)
if __name__ == '__main__':
NUM_BITS = 7
d = torch.randint(0, 16, (3, 6))
b = dec2bin(d, NUM_BITS)
# print(d)
# print(b)
# print(b.shape)
# print("num of total bits: {}".format(np.prod(b.shape)))
d_rec = bin2dec(b, NUM_BITS)
# print(d_rec)
print(abs(d - d_rec).max()) # should be 0.
If the input is unsigned bytes and the output width is 8 bits:
>>> binary = np.unpackbits(np.array([0xaa, 0xf0], dtype=np.uint8))
>>> print(torch.tensor(binary))
tensor([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0], dtype=torch.uint8)
Note that unpackbits() only operates with np.uint8.
def decimal_to_binary_tensor(value, width=0):
string = format(value, '0{}b'.format(width))
binary = [0 if c == '0' else 1 for c in string]
return torch.tensor(binary, dtype=torch.uint8)
Examples:
>>> print(decimal_to_binary_tensor(6, width=8))
tensor([0, 0, 0, 0, 0, 1, 1, 0], dtype=torch.uint8)
>>> print(decimal_to_binary_tensor(6))
tensor([1, 1, 0], dtype=torch.uint8)
Related
How to make a checkerboard in Pytorch?
I see that a simple checkerboard pattern can be created fairly concisely with numpy Does anyone know if a checkerboard where each square may contain multiple values could be created? E.g.: 1 1 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 0 0 0 1 1 0 0
Although there is no equivalent of np.indices in PyTorch, you can still find a workaround using a combination of torch.arange, torch.meshgrid, and torch.stack: def indices(h,w): return torch.stack(torch.meshgrid(torch.arange(h), torch.arange(w))) This allows you to define a base tensor with a checkboard pattern following your linked post: >>> base = indices(2,3).sum(axis=0) % 2 tensor([[0, 1, 0], [1, 0, 1]]) Then you can repeat the row end columns with torch.repeat_interleave: >>> base.repeat_interleave(2, dim=0).repeat_interleave(2, dim=1) tensor([[0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0], [1, 1, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]]) And you can take the opposite of a given checkboard x by computing 1-x. So you could define a function like this: def checkerboard(shape, k): """ shape: dimensions of output tensor k: edge size of square """ h, w = shape base = indices(h//k, w//k).sum(dim=0) % 2 x = base.repeat_interleave(k, 0).repeat_interleave(k, 1) return 1-x And try with: >>> checkerboard((4,6), 2) tensor([[1, 1, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1], [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]])
Generate all n-bit binary bit patterns in order of their sum
I need a generator that yields every bit pattern of n bits in order of their sum (and more). For example for n=3, 1. sum([0, 0, 0]) = 0 ✓ 2. sum([1, 0, 0]) = 1 ✓ 3. sum([0, 1, 0]) = 1 ✓ 4. sum([1, 1, 0]) = 2 ⨯ should be swapped with 5. 5. sum([0, 0, 1]) = 1 ⨯ 6. sum([1, 0, 1]) = 2 ✓ 7. sum([0, 1, 1]) = 2 ✓ 8. sum([1, 1, 1]) = 3 ✓ Note that even though 3 and 5 have the same sum, 5 should be generated after 3. The correct order would have been, 000, 100, 010, 001, 110, 101, 011, 111. The idea here is that if this (2ⁿ, n) dimension matrix was multiplied by a (n, 1) vector that is sorted in ascending order than the product would be sorted as well. Eliminating the need to sort this product will help in optimising an experiment I am trying to run. Here is my rather inefficient and incomplete attempt, def forwards(n): ls = [0]*n for i in range(n): for j in range(n-i): copy = list(ls) copy[j] = 1 yield copy ls[-(i+1)] = 1 As you can see, this does get the order right but misses some patterns. Here is another somewhat efficient but wrong order attempt. def forwards(n): for i in range(1 << n): yield [(i >> k) & 1 for k in range(n)] This one generates all patterns but in the wrong (shown in the example above) order. I need this function to be efficient so solutions where a string is generated and then characters are converted to integers are discouraged. Lastly, I am working in Python 3.9. You can use Numpy.
I believe this gives you the order you want:
First, sort in ascending order by number of 1's
Next, sort in descending order by lexicographical order
from itertools import combinations
def forwards(n):
for one_bits in range(n + 1):
for combination in combinations(range(n), one_bits):
yield [1 if x in combination else 0 for x in range(n)]
for x in forwards(4):
print("{}, one bits = {}, binary value = {}".format(x, sum(x), sum(x[i] * 2**(3 - i) for i in range(4))))
This works by handling the first condition in the first for loop for one_bits in range(n + 1):, and generating all possible N-sized combinations of indices between 0 and n - 1, and then those indices are set to 1, else 0.
This prints
[0, 0, 0, 0], one bits = 0, binary value = 0
[1, 0, 0, 0], one bits = 1, binary value = 8
[0, 1, 0, 0], one bits = 1, binary value = 4
[0, 0, 1, 0], one bits = 1, binary value = 2
[0, 0, 0, 1], one bits = 1, binary value = 1
[1, 1, 0, 0], one bits = 2, binary value = 12
[1, 0, 1, 0], one bits = 2, binary value = 10
[1, 0, 0, 1], one bits = 2, binary value = 9
[0, 1, 1, 0], one bits = 2, binary value = 6
[0, 1, 0, 1], one bits = 2, binary value = 5
[0, 0, 1, 1], one bits = 2, binary value = 3
[1, 1, 1, 0], one bits = 3, binary value = 14
[1, 1, 0, 1], one bits = 3, binary value = 13
[1, 0, 1, 1], one bits = 3, binary value = 11
[0, 1, 1, 1], one bits = 3, binary value = 7
[1, 1, 1, 1], one bits = 4, binary value = 15
'matrix' object has no attribute 'eigenvals'
I have the following code
import numpy as np
import sympy as sp
def bra(i,d):
arr = np.zeros((1,d))
if i <= (d-1):
arr[:,i] = 1
else:
print("Index Out of bounds")
return arr
def density(i,j,d):
return bra(i,d).T*bra(j,d)
SIGMA = (1/3)*(np.kron(np.kron(bra(0,3),bra(1,3)).T,np.kron(bra(0,3),bra(1,3)))+np.kron(np.kron(bra(1,3),bra(2,3)).T,np.kron(bra(1,3),bra(2,3)))+np.kron(np.kron(bra(2,3),bra(0,3)).T,np.kron(bra(2,3),bra(0,3))))
DELTA = (1/3)*(np.kron(np.kron(bra(1,3),bra(0,3)).T,np.kron(bra(1,3),bra(0,3)))+np.kron(np.kron(bra(2,3),bra(1,3)).T,np.kron(bra(2,3),bra(1,3)))+np.kron(np.kron(bra(0,3),bra(2,3)).T,np.kron(bra(0,3),bra(2,3))))
Essentially bra(i,d) gives a (1,d) array with (1,i)th element as one and rest as zero. For example,
bra(0,3)=[[1,0,0]]
bra(1,3)=[[0,1,0]]
bra(0,3)=[[0,0,1]]
density(i,j,d) returns (d,d) matrix with (i,j)th element as one rest as zero, for example,
density(0,1,3) = array([[0., 1., 0.], [0., 0., 0.],[0., 0., 0.]]).
Using the above codes, I have produced a (9,9) Matrix object by using np.kron
a = sp.symbols('a', positive = True)
HORO = (2/21)*(np.kron(density(0,0,3),density(0,0,3))+np.kron(density(1,0,3),density(0,1,3))+np.kron(density(0,0,3),density(2,2,3))
+np.kron(density(0,1,3),density(1,0,3))+np.kron(density(1,1,3),density(1,1,3))+np.kron(density(2,1,3),density(1,2,3))
+np.kron(density(0,2,3),density(2,0,3))+np.kron(density(1,2,3),density(2,1,3))+np.kron(density(2,2,3),density(2,2,3)))+(a/7)*SIGMA+((5-a)/7)*DELTA
M = np.asmatrix(HORO)
It can be shown that M matrix is invertible and it
is the following (9,9) matrix
matrix([[0.0952380952380952, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0.0476190476190476*a, 0, 0.0952380952380952, 0, 0, 0, 0, 0],
[0, 0, 0.333333333333333 - 0.0476190476190476*a, 0, 0, 0,
0.0952380952380952, 0, 0],
[0, 0.0952380952380952, 0,
0.238095238095238 - 0.0476190476190476*a, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0.0952380952380952, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0.0476190476190476*a, 0, 0.0952380952380952, 0],
[0, 0, 0, 0, 0, 0, 0.0476190476190476*a, 0, 0],
[0, 0, 0, 0, 0, 0.0952380952380952, 0,
0.238095238095238 - 0.0476190476190476*a, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0.0952380952380952]], dtype=object)
For this symbolic matrix I want to calculate the eigenvalues as
M.eigenvals()
However, it is returning the following error
AttributeError: 'matrix' object has no attribute 'eigenvals'
I can't figure out what went wrong.
Usually, numpy and sympy don't mix well. Numpy can't work with sympy functions and symbols. Also, sympy tries to calculate exact symbolic solutions, which doesn't work well together with floats (sympy strongly prefers integers, rationals and symbolic expressions such as sp.sqrt()).
In this case, provided you don't change too much, numpy managed to calculate the matrix elements well (sums and productions are executed via the underlying standard Python).
Now, if you just use that matrix in sympy, you get:
M = sp.Matrix(HORO)
print(M.eigenvals())
You get:
{0.0952380952380952: 3,
0.119047619047619 - 0.152455338986496 * sqrt(0.0975609756097561 * a ** 2 - 0.48780487804878 * a + 1.0): 2,
0.152455338986496 * sqrt(0.0975609756097561 * a ** 2 - 0.48780487804878 * a + 1.0) + 0.119047619047619: 2,
0.0476190476190476 * a: 1,
0.333333333333333 - 0.0476190476190476 * a: 1}
A better approach uses nsimplify to convert floats to rationals:
M = sp.Matrix(sp.nsimplify(HORO))
print(M.eigenvals())
This gives a nicer symbolic solution:
{2 / 21: 3,
5 / 42 - sqrt(4 * a ** 2 - 20 * a + 41) / 42: 2,
sqrt(4 * a ** 2 - 20 * a + 41) / 42 + 5 / 42: 2,
a / 21: 1,
1 / 3 - a / 21: 1}
How to initialize an 3D array variable in Gekko?
I'm trying to solve a step from a three-dimensional master timetabling model, which involvs periods(5), courses(19) and locations(8). So I have a problem to initialize these variables with an 3D array in Gekko. Without this initialization the algorithm doesn't converge, after more than 15 minutes run and 1000 iterations. When I try initialize, this error appears: " raise Exception(response) Exception: #error: Equation Definition Equation without an equality (=) or inequality (>,<) true STOPPING... " How can I fix this problem? Follows a version of my code: import numpy as np from gekko import GEKKO # Input data # Schedule of periods and courses sched = np.array([ [0, 1, 0, 0, 1], [0, 0, 1, 1, 0], [0, 0, 1, 1, 0], \ [0, 0, 0, 0, 1], [1, 0, 0, 0, 1], [0, 0, 0, 1, 1], [0, 1, 1, 0, 0], \ [1, 0, 0, 1, 0], [0, 1, 0, 0, 1], [1, 1, 0, 0, 0], [0, 1, 1, 0, 0], \ [0, 1, 1, 0, 0], [1, 0, 0, 1, 0], [1, 0, 0, 1, 0], [0, 0, 1, 0, 1], \ [1, 0, 1, 0, 0], [0, 1, 0, 1, 0], [0, 0, 1, 1, 0], [0, 1, 0, 0, 1] ], dtype=np.int64) # Initial allocation of all periods, courses and locations alloc=np.array([0,0,0,0,0,0,0,0,0,0,0,0,1,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,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,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,1,1,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,1,0,0,0,1,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,0,0,0,0,0,0,0,0,\ 0,0,0,0,0,0,1,1,0,1,1,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,1,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,0,1,0,0,0,0,0,0,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,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,1,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,1,0,0,0,1,0,1,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,1,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,0,0,0,0,0,0,0,0,0,0,1,0,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,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,1,1,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,0,0,0,0,\ 0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,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,1,0,0,0,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,0,0,0,0,0,0,0,0,0], dtype=np.int64) # Number of students enrolled in each course enrol = np.array([ 60, 60, 60, 40, 40, 110, 120, 50, 60, 55, 50, \ 55, 40, 64, 72, 50, 50, 55, 55], dtype=np.float64) # Capacity of each location (classroom) capac = np.array([ 60, 60, 120, 60, 80, 60, 60, 65], dtype=np.float64) # Total costs of using each location costs = np.array([ 9017.12, 9017.12, 12050.24, 9017.12, 9413.68, 9017.12, \ 9017.12, 9188.96 ]) # Estimated cost of each location by period and student ecost = np.repeat(np.array([[costs[i]*pow(enrol[j]*5,-1) for j in range(19)] for i in range(8)]), 5) # The model construction m = GEKKO() # Constant arrays x = m.Array(m.Const,(19,5)) y = m.Array(m.Const,(8,19,5)) N = m.Array(m.Const,(19)) C = m.Array(m.Const,(8)) Ec = m.Array(m.Const,(8,19,5)) Ecy = m.Array(m.Const,(8,19,5)) Alt = m.Array(m.Const,(8,19,5)) for k in range(5): for j in range(19): N[j] = enrol[j] x[j,k] = sched[j,k] for i in range(8): C[i] = capac[i] Ec[i,j,k] = ecost[k+j*5+i*19*5] y[i,j,k] = alloc[k+j*5+i*19*5] Ecy[i,j,k] = Ec[i,j,k]*y[i,j,k] if sched[j,k]==1: Alt[i,j,np.where(sched[j,:]==1)[0][0]]=-sched[j,k]*(1-sum(sched[j,:])) if sum(sched[j,:])==2: Alt[i,j,np.where(sched[j,:]==1)[0][1]]=sched[j,k]*(1-sum(sched[j,:])) else: Alt[i,j,k]=0 # Initialize the variable z with the initial value y: # These commented approaches produce the error. z = m.Array(m.Var,(8,19,5),lb=0,ub=1,integer=True) #for i in range(8): # for j in range(19): # for k in range(5): # z[i,j,k] = y[i,j,k] # nor #z = m.Array(m.Var,(8,19,5),value=y,lb=0,ub=1,integer=True) # Intermediate equations Ecz = m.Array(m.Var,(8,19,5),lb=0) Altz = m.Array(m.Var,(8,19)) for i in range(8): for j in range(19): Altz[i,j]=m.Intermediate(m.sum(Alt[i,j,:]*z[i,j,:])) for k in range(5): Ecz[i,j,k]=m.Intermediate(Ec[i,j,k]*z[i,j,k]) # Constraints m.Equation(m.sum(m.sum(m.sum(Ecz)))<=m.sum(m.sum(m.sum(Ecy)))) for j in range(19): for k in range(5): m.Equation(m.sum(z[:,j,k])==x[j,k]) for i in range(8): for k in range(5): m.Equation(m.sum(z[i,:,k])==m.sum(y[i,:,k])) for i in range(8): for j in range(19): m.Equation(m.sum((C[i]/N[j]-x[j,:])*z[i,j,:])>=0) # Objective: to minimize the quantity of courses allocated in different locations # Example: with the solution y, I have 12 courses in different locations in the periods # print(sum([sum(Alt[i,j,:]*y[i,j,:])**2 for j in range(19) for i in range(8)])/2) for i in range(8): for j in range(19): m.Obj(Altz[i,j]**2/2) # Options and final results m.options.SOLVER=1 m.options.IMODE=2 m.solve() print(z) print(m.options.OBJFCNVAL) Note: My original problem has 20 periods, 171 courses, and 18 locations.
Use z[i,j,k].value = y[i,j,k] to give an initial guess for z. Using z[i,j,k] = y[i,j,k] redefines z entries as floating point numbers instead of gekko variable types. One other issue is that the variables Ecz and Altz are defined as Variables as m.Var and then overridden as Intermediates. Instead, try allocating them and assigning them as intermediates: Ecz = np.empty((8,19,5),dtype=object) Altz = np.empty((8,19),dtype=object) Use flatten() to simplify the summation of all elements of the 3 dimensional array. m.Equation(m.sum(Ecz.flatten())<=sum(Ecy.flatten())) The constant arrays can be defined as numpy arrays to avoid additional symbolic processing by Gekko. This speeds up the model compile time but has no effect on the final solution. x = np.empty((19,5)) y = np.empty((8,19,5)) N = np.empty((19)) C = np.empty((8)) Ec = np.empty((8,19,5)) Ecy = np.empty((8,19,5)) Alt = np.empty((8,19,5)) The IMODE should be 3 for optimization. IMODE=2 is for parameter regression. IMODE=2 should also work for this problem but 3 is the correct option because you aren't trying to fit to data. m.options.IMODE=3 Try using IPOPT to obtain an initial non-integer solution and then use APOPT to find an integer solution. m.solver_options = ['minlp_gap_tol 1.0e-2',\ 'minlp_maximum_iterations 10000',\ 'minlp_max_iter_with_int_sol 500',\ 'minlp_branch_method 1'] Mixed Integer Nonlinear Programming (MINLP) problems can be challenging to solve so you may need to use some of the solver options to speed up the solution. Try minlp_branch_method 1 to help the solver find an initial integer solution to do better pruning. The gap tolerance can also help to speed up the solution if a sub-optimal solution is okay. Below is the complete script. Consider using remote=False to run locally instead of using the public servers, especially for large optimization problems. import numpy as np from gekko import GEKKO # Input data # Schedule of periods and courses sched = np.array([ [0, 1, 0, 0, 1], [0, 0, 1, 1, 0], [0, 0, 1, 1, 0], \ [0, 0, 0, 0, 1], [1, 0, 0, 0, 1], [0, 0, 0, 1, 1], [0, 1, 1, 0, 0], \ [1, 0, 0, 1, 0], [0, 1, 0, 0, 1], [1, 1, 0, 0, 0], [0, 1, 1, 0, 0], \ [0, 1, 1, 0, 0], [1, 0, 0, 1, 0], [1, 0, 0, 1, 0], [0, 0, 1, 0, 1], \ [1, 0, 1, 0, 0], [0, 1, 0, 1, 0], [0, 0, 1, 1, 0], [0, 1, 0, 0, 1] ], dtype=np.int64) # Initial allocation of all periods, courses and locations alloc=np.array([0,0,0,0,0,0,0,0,0,0,0,0,1,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,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,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,1,1,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,1,0,0,0,1,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,0,0,0,0,0,0,0,0,\ 0,0,0,0,0,0,1,1,0,1,1,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,1,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,0,1,0,0,0,0,0,0,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,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,1,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,1,0,0,0,1,0,1,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,1,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,0,0,0,0,0,0,0,0,0,0,1,0,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,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,1,1,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,0,0,0,0,\ 0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,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,1,0,0,0,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,0,0,0,0,0,0,0,0,0], dtype=np.int64) # Number of students enrolled in each course enrol = np.array([ 60, 60, 60, 40, 40, 110, 120, 50, 60, 55, 50, \ 55, 40, 64, 72, 50, 50, 55, 55], dtype=np.float64) # Capacity of each location (classroom) capac = np.array([ 60, 60, 120, 60, 80, 60, 60, 65], dtype=np.float64) # Total costs of using each location costs = np.array([ 9017.12, 9017.12, 12050.24, 9017.12, 9413.68, 9017.12, \ 9017.12, 9188.96 ]) # Estimated cost of each location by period and student ecost = np.repeat(np.array([[costs[i]*pow(enrol[j]*5,-1) for j in range(19)] for i in range(8)]), 5) # The model construction m = GEKKO(remote=True) # Constant arrays x = np.empty((19,5)) y = np.empty((8,19,5)) N = np.empty((19)) C = np.empty((8)) Ec = np.empty((8,19,5)) Ecy = np.empty((8,19,5)) Alt = np.empty((8,19,5)) for k in range(5): for j in range(19): N[j] = enrol[j] x[j,k] = sched[j,k] for i in range(8): C[i] = capac[i] Ec[i,j,k] = ecost[k+j*5+i*19*5] y[i,j,k] = alloc[k+j*5+i*19*5] Ecy[i,j,k] = Ec[i,j,k]*y[i,j,k] if sched[j,k]==1: Alt[i,j,np.where(sched[j,:]==1)[0][0]]=-sched[j,k]*(1-sum(sched[j,:])) if sum(sched[j,:])==2: Alt[i,j,np.where(sched[j,:]==1)[0][1]]=sched[j,k]*(1-sum(sched[j,:])) else: Alt[i,j,k]=0 # Initialize the variable z with the initial value y: # These commented approaches produce the error. z = m.Array(m.Var,(8,19,5),lb=0,ub=1,integer=True) for i in range(8): for j in range(19): for k in range(5): z[i,j,k].value = y[i,j,k] # nor #z = m.Array(m.Var,(8,19,5),value=y,lb=0,ub=1,integer=True) # Intermediate equations Ecz = np.empty((8,19,5),dtype=object) Altz = np.empty((8,19),dtype=object) for i in range(8): for j in range(19): Altz[i,j]=m.Intermediate(m.sum(Alt[i,j,:]*z[i,j,:])) for k in range(5): Ecz[i,j,k]=m.Intermediate(Ec[i,j,k]*z[i,j,k]) # Constraints m.Equation(m.sum(Ecz.flatten())<=sum(Ecy.flatten())) for j in range(19): for k in range(5): m.Equation(m.sum(z[:,j,k])==x[j,k]) for i in range(8): for k in range(5): m.Equation(m.sum(z[i,:,k])==m.sum(y[i,:,k])) for i in range(8): for j in range(19): m.Equation(m.sum((C[i]/N[j]-x[j,:])*z[i,j,:])>=0) # Objective: to minimize the quantity of courses allocated in different locations # Example: with the solution y, I have 12 courses in different locations in the periods # print(sum([sum(Alt[i,j,:]*y[i,j,:])**2 for j in range(19) for i in range(8)])/2) for i in range(8): for j in range(19): m.Obj(Altz[i,j]**2/2) # Options and final results m.options.IMODE=3 # Initialize with IPOPT m.options.SOLVER=3 m.solve() # Integer solution with APOPT m.options.SOLVER=1 m.solver_options = ['minlp_gap_tol 1.0e-2',\ 'minlp_maximum_iterations 10000',\ 'minlp_max_iter_with_int_sol 500',\ 'minlp_branch_method 1'] m.solve() print(z) print(m.options.OBJFCNVAL)
Printing Paths in Dijkstra's shortest path Python3
I'm having issues with the code below where it's not displaying any paths for each vertex. Vertex and Distance from the source is displaying correctly, but for the path section of the output is blank. What am I missing? I would love to get some feedbacks or suggestions or even answer to this nightmare. I just can't seem to figure out what is causing the paths from displaying anything. I'm still fairly new to Python and I could really use some help!
Output of my current code
class Graph:
def minDistance(self, dist, queue):
# Initialize min value and min_index as -1
minimum = float("Inf")
min_index = -1
# from the dist array,pick one which
# has min value and is till in queue
for i in range(len(dist)):
if dist[i] < minimum and i in queue:
minimum = dist[i]
min_index = i
return min_index
def printPath(self, parent, j):
# Base Case : If j is source
if parent[j] == -1:
print()
j,
return
self.printPath(parent, parent[j])
print()
j,
def printSolution(self, dist, parent):
src = 0
print("Vertex \t\tDistance from Source\tPath")
for i in range(1, len(dist)):
print(("\n%d --> %d \t\t%d \t\t\t\t\t" % (src, i, dist[i])), end=' ')
self.printPath(parent, i)
def dijkstra(self, graph, src):
row = len(graph)
col = len(graph[0])
dist = [float("Inf")] * row
parent = [-1] * row
dist[src] = 0
queue = []
for i in range(row):
queue.append(i)
while queue:
u = self.minDistance(dist, queue)
queue.remove(u)
for i in range(col):
if graph[u][i] and i in queue:
if dist[u] + graph[u][i] < dist[i]:
dist[i] = dist[u] + graph[u][i]
parent[i] = u
self.printSolution(dist, parent)
g = Graph()
graph = [[0, 4, 0, 0, 0, 0, 0, 8, 0],
[4, 0, 8, 0, 0, 0, 0, 11, 0],
[0, 8, 0, 7, 0, 4, 0, 0, 2],
[0, 0, 7, 0, 9, 14, 0, 0, 0],
[0, 0, 0, 9, 0, 10, 0, 0, 0],
[0, 0, 4, 14, 10, 0, 2, 0, 0],
[0, 0, 0, 0, 0, 2, 0, 1, 6],
[8, 11, 0, 0, 0, 0, 1, 0, 7],
[0, 0, 2, 0, 0, 0, 6, 7, 0]
]
g.dijkstra(graph, 0)
The basic issue with your code is that the printPath method is only outputting blanks and secondly, the printSolution method is not including the results of the printPath method. To fix these problems:
1 rewrite the printPath function as below:
def printPath(self, parent, j, l):
# Returns a list from destination to source
# Base case when j = source
if parent[j] == -1:
return l
else:
l.append(j)
return self.printPath(parent, parent[j], l)
Then rewrite the printSolution method as follows:
Note: I used the f format structure to simplify my print statement
def printSolution(self, dist, parent):
src = 0
print("Vertex \t\tDistance from Source\tPath")
for i in range(1, len(dist)):
st = f"\n{src} --> {i}\t\t{dist[i]}\t\t\t\t\t{self.printPath(parent,i,[])[::-1]}"
#print(("\n%d --> %d \t\t%d \t\t\t\t\t" % (src, i, dist[i])), end=' ')
#self.printPath(parent, i)
print (st)