In [2]:
%matplotlib inline
import networkx as nx
#import pygraphviz
import pyparsing
import numpy as np
import matplotlib.pylab as plt
from IPython.display import Math
In [3]:
A = np.array([[0,1,1],[0,0,1],[1,0,0]])
G = nx.Graph(A)
labels = {0: "a", 1:"b", 2:"c"}
pos = [(0,0),(3,1),(1,0)]
plt.figure(figsize=(12,2.5))
nx.draw(G, pos, cmap='jet', edge_color=[0.1,0.7,0.9], node_color="white", node_size=500, labels=labels, font_size=10, arrows=True)
#nx.draw(G, pos, node_color="white", node_size=500, arrows=False)
#nx.draw_graphviz(G,node_size=500, labels=labels, font_size=24, arrows=True)
plt.show()
#nx.draw_networkx()
In [5]:
from itertools import product
M = 6;
N = 6
Z = 1.7
NN = M*N
A = np.zeros((NN,NN))
X = np.zeros((NN))
Y = np.zeros((NN))
sig = 0.1;
coords = []
#cols = ("blue","red","yellow","black")
cols = ("black","black")
col = []
for i,j in product(range(N),range(M)):
ex = np.random.randn(1)*sig
ey = np.random.randn(1)*sig
coords.append((j,i))
X[i*M+j] = i+ex
Y[i*M+j] = j+ey
col.append(np.random.choice(cols))
for k,r in product(range(NN),range(NN)):
if k != r:
d = (X[k]-X[r])**2 + (Y[k]-Y[r])**2
A[k,r] = 1 if d < Z else 0
G = nx.Graph(A)
plt.figure(figsize=(M,N))
#nx.draw(G, pos, node_color="white", node_size=500, labels=labels, font_size=10, arrows=True)
nx.draw(G, coords, node_color='black', node_size=200, arrows=False, linewidths=14.)
nx.draw_networkx_nodes(G, coords, node_color='white', node_size=200, arrows=False, linewidths=11., linecolors='black')
#nx.draw_graphviz(G,node_size=500, labels=labels, font_size=24, arrows=True)
plt.show()
In [6]:
#t = nx.dfs_tree(G,17)
t = nx.bfs_tree(G,1)
#t = nx.prim_mst(G)
plt.figure(figsize=(M,N))
nx.draw(t, coords, node_size=200,node_color="black",linewidths=14.)
nx.draw_networkx_nodes(t, coords, node_color="white", node_size=200,linewidths=11.)
plt.show()
In [7]:
#nx.view_pygraphviz(G)
N = 20
#H = nx.random_graphs.watts_strogatz_graph(N,5,0.1)
H = nx.random_graphs.random_regular_graph(3,N)
lbl = {e:e for e in range(N)}
#nx.view_pygraphviz(H)
nx.draw_networkx_nodes(H,node_color="black",alpha=1, node_size=500, pos=nx.spectral_layout(H))
nx.draw(H,labels=lbl,node_color="white",alpha=1, node_size=400, pos=nx.spectral_layout(H))
In [10]:
G = nx.Graph()
d = 10
G.add_node(0)
coord = [(0.5,0)]
depth = [0]
for n in range(2,256*4):
G.add_node(n-1)
p = int(np.floor(n/2))
depth.append(depth[p-1]+1)
if 2*p==n: # left child
ep = -(1.0/(2**(depth[p-1]+2)))
else:
ep = 1.0/(2**(depth[p-1]+2))
coord.append((coord[p-1][0]+ep,-(depth[p-1]+1)))
G.add_edge(n-1,p-1)
plt.figure(figsize=(35,6))
nx.draw(G, coord, node_size=50, node_color='black')
#nx.draw_shell
In [7]:
import heapq
import numpy as np
N = 50
thr = 0.35
lb = 0.1
X = np.random.rand(N,2)
D = np.zeros((N,N))
for i,j in product(range(N),range(N)):
D[i,j] = np.sqrt((X[i,0]-X[j,0])**2 + (X[i,1]-X[j,1])**2)
if D[i,j]>thr or D[i,j]<lb :
D[i,j] = np.Inf
visited = np.empty(N,dtype=bool); visited.fill(False)
root = 0
visited[root] = True
numvis = 1;
spt = np.empty(N,dtype=int)
spt.fill(-1)
spt[root] = -1
q = []
for j in range(N):
if np.isfinite(D[root,j]):
heapq.heappush(q, (D[root,j], root, j))
while numvis<N:
if len(q)==0:
break;
d,i,j = heapq.heappop(q)
while len(q)>0 and visited[j]:
d,i,j = heapq.heappop(q)
spt[j] = i
visited[j] = True
numvis+=1
for k in range(N):
if np.isfinite(D[j,k]) and not visited[k]:
heapq.heappush(q, (D[j,k], j, k))
print(spt)
plt.figure(figsize=(10,10))
plt.plot(X[:,0],X[:,1],'o')
for i,j in product(range(N),range(N)):
if not np.isinf(D[i,j]):
plt.plot(X[[i,j],0],X[[i,j],1],'k:')
for u in range(N):
if spt[u]!=-1:
plt.plot(X[[u,spt[u]],0],X[[u,spt[u]],1],'r-')
plt.show()
In [3]:
import matplotlib.pyplot as plt
import matplotlib.tri as tri
import numpy as np
import math
min_radius = 0.1
N = 100
x = np.random.rand(N)
y = np.random.rand(N)
# Create the Triangulation; no triangles so Delaunay triangulation created.
triang = tri.Triangulation(x, y)
# Mask off unwanted triangles.
xmid = x[triang.triangles].mean(axis=1)
ymid = y[triang.triangles].mean(axis=1)
mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
triang.set_mask(mask)
# Plot the triangulation.
plt.figure(figsize=(5,5))
plt.gca().set_aspect('equal')
plt.triplot(triang, 'bo-')
plt.title('triplot of Delaunay triangulation')
plt.show()
In [1]:
import pygraphviz as pgv
from IPython.display import Image
from IPython.display import display
In [9]:
def random_alphabet(N=20, first_letter='A'):
"""Generates unique strings to be used as index_names"""
if N<27:
alphabet = [chr(i+ord(first_letter)) for i in range(N)]
else:
alphabet = ['X'+str(i) for i in range(N)]
return alphabet
def random_parents(alphabet, max_indeg=3):
"""Random DAG generation"""
N = len(alphabet)
print(alphabet)
indeg = lambda: np.random.choice(range(1,max_indeg+1))
parents = {a:[b for b in np.random.choice(alphabet[0:(1 if i==0 else i)], replace=False, size=min(indeg(),i))] for i,a in enumerate(alphabet)}
return parents
def show_dag_image(index_names, parents, imstr='_BJN_tempfile.png', prog='dot'):
name2idx = {name: i for i,name in enumerate(index_names)}
A = pgv.AGraph(directed=True)
for i_n in index_names:
A.add_node(name2idx[i_n], label=i_n)
for j_n in parents[i_n]:
A.add_edge(name2idx[j_n], name2idx[i_n])
A.layout(prog=prog)
A.draw(imstr)
display(Image(imstr))
return
index_names = random_alphabet(10)
parents = random_parents(index_names, 3)
show_dag_image(index_names, parents, prog='neato')
Road Network
We will build a 2D square grid where neighbors are connected
Remove Random junctions for a more realistic view Compute a smooth height z by a linear dynamics Transform x,y,z and print
In [139]:
import numpy as np
import scipy as sc
import pandas as pd
from itertools import product
def ind2idx(i,j, M, N):
return i + M*j
def idx2ind(k, M, N):
return k % M, k//M
def neigh(i,j, M, N):
ng = {'n': None, 's': None, 'w': None, 'e': None}
# north
if i>0:
ng['n'] = ind2idx(i-1,j,M,N)
# south
if i<M-1:
ng['s'] = ind2idx(i+1,j,M,N)
# west
if j>0:
ng['w'] = ind2idx(i,j-1,M,N)
#east
if j<N-1:
ng['e'] = ind2idx(i,j+1,M,N)
return ng
# Build a grid of junctions
M, N = 12,15
#ng = neigh(0,0,M,N)
#print(ng)
## Build the Adjecency list of the undirected graph
Adj = [[] for i in range(M*N)]
for j in range(N):
for i in range(M):
k = ind2idx(i,j,M,N)
ng = neigh(i,j,M,N)
south = ng['s']
if south is not None:
Adj[k].append(south)
Adj[south].append(k)
if np.random.rand()<0.8:
east = ng['e']
if east is not None:
Adj[k].append(east)
Adj[east].append(k)
# print(k,Adj[k])
# Kill a fraction of nodes randomly
kill = np.random.choice(range(M*N), size=M*N//10)
for k in kill:
for u in Adj[k]:
Adj[u].remove(k)
Adj[k] = []
## Place nodes on a perturbed grid
X = 0.9*np.random.rand(N) + np.arange(0, N)
Y = 0.9*np.random.rand(M) + np.arange(0, M)
Coords = np.zeros((M*N, 3))
for k in range(M*N):
i, j = idx2ind(k, M, N)
Coords[k, 0] = X[j]+0.1*np.random.randn()
Coords[k, 1] = Y[i]+0.1*np.random.randn()
Coords[k, 2] = np.random.rand()
## Iterate to get a smooth terrain
EPOCHS = 30
for e in range(EPOCHS):
perm = np.random.permutation(M*N)
for k in perm:
if Adj[k]:
Coords[k,2] = 0.9*Coords[k,2] + 0.1*np.mean(Coords[Adj[k],2])
In [136]:
plot_topology(Adj, M, N)
In [140]:
merge = np.random.choice(range(M*N), replace=False, size=30)
for u in merge:
if Adj[u]:
v = np.random.choice(Adj[u])
# Disconnect v from u
Adj[v].remove(u)
Adj[u].remove(v)
## transfer all the remaining edges to v
for w in Adj[u]:
if w not in Adj[v]:
Adj[v].append(w)
Adj[w].append(v)
Adj[w].remove(u)
Adj[u] = []
In [141]:
plot_topology(Adj, M, N)
In [96]:
## Print node coordinates
for k in range(M*N):
print("%2.1f, %2.1f, %2.1f" % (Coords[k, 0], Coords[k, 1], Coords[k, 0]))
# Print Edges
for k in range(M*N):
for u in Adj[k]:
print('%d,%d' % (k,u))
In [112]:
import matplotlib.pylab as plt
def plot_topology(Adj, M, N):
plt.figure(figsize=(10,10))
for k,ls in enumerate(Adj):
i,j = idx2ind(k, M,N)
for u in ls:
i_target, j_target = idx2ind(u, M,N)
plt.plot([j, j_target ],[i, i_target],'k')
if Adj[k]:
plt.plot(j, i,'ro')
plt.show()
plot_topology(Adj, M, N)
In [98]:
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(figsize=(10,10))
ax = fig.add_subplot(111, projection='3d')
for k,ls in enumerate(Adj):
for u in ls:
ax.plot([Coords[k,0], Coords[u,0] ],[Coords[k,1], Coords[u,1] ], [Coords[k,2], Coords[u,2] ],'k')
if Adj[k]:
ax.plot([Coords[k,0]], [Coords[k,1]], [Coords[k,2]], 'ro')
ax.set_zlim([0, 1])
plt.show()
In [69]:
for k in range(M*N):
print("%2.1f, %2.1f, %2.1f" % (Coords[k, 0], Coords[k, 1], Coords[k, 0]))
for k in range(M*N):
for u in Adj[k]:
print('%d,%d' % (k,u))
In [11]:
G = nx.Graph(A)
plt.figure(figsize=(M,N))
#nx.draw(G, pos, node_color="white", node_size=500, labels=labels, font_size=10, arrows=True)
nx.draw(G, coords, node_color='black', node_size=200, arrows=False, linewidths=14.)
nx.draw_networkx_nodes(G, coords, node_color='white', node_size=200, arrows=False, linewidths=11., linecolors='black')
#nx.draw_graphviz(G,node_size=500, labels=labels, font_size=24, arrows=True)
plt.show()
In [7]:
import itertools
import numpy as np
import matplotlib.pylab as plt
import daft
# Instantiate the PGM.
pgm = daft.PGM([3.6, 3.6], origin=[0.7, 0.7], node_unit=0.4, grid_unit=1,
directed=False)
for i, (xi, yi) in enumerate(itertools.product(range(1, 5), range(1, 5))):
pgm.add_node(daft.Node(str(i), "", xi, yi))
for e in [(4, 9), (6, 7), (3, 7), (10, 11), (10, 9), (10, 14),
(10, 6), (10, 7), (1, 2), (1, 5), (1, 0), (1, 6), (8, 12), (12, 13),
(13, 14), (15, 11)]:
pgm.add_edge(str(e[0]), str(e[1]))
# Render and save.
pgm.render()
#pgm.figure.savefig("mrf.pdf")
#pgm.figure.savefig("mrf.png", dpi=150)
plt.show(pgm.ax)
In [9]:
from matplotlib import rc
rc("font", family="serif", size=12)
rc("text", usetex=True)
import daft
pgm = daft.PGM([3.6, 2.4], origin = [1.15, 0.8], node_ec="none")
pgm.add_node(daft.Node("cloudy", r"cloudy", 3, 3))
pgm.add_node(daft.Node("rain", r"rain", 2, 2))
pgm.add_node(daft.Node("sprinkler", r"sprinkler", 4, 2))
pgm.add_node(daft.Node("wet", r"grass wet", 3, 1))
pgm.add_edge("cloudy", "rain")
pgm.add_edge("cloudy", "sprinkler")
pgm.add_edge("rain", "wet")
pgm.add_edge("sprinkler", "wet")
pgm.render()
plt.show(pgm.ax)
In [11]:
from matplotlib import rc
ff = "comic sans ms"
# ff = "impact"
# ff = "times new roman"
rc("font", family=ff, size=12)
rc("text", usetex=False)
import daft
pgm = daft.PGM([3.6, 1.8], origin=[2.2, 1.6], aspect=2.1)
pgm.add_node(daft.Node("confused", r"confused", 3.0, 3.0))
pgm.add_node(daft.Node("ugly", r"ugly font", 3.0, 2.0, observed=True))
pgm.add_node(daft.Node("bad", r"bad talk", 5.0, 2.0, observed=True))
pgm.add_edge("confused", "ugly")
pgm.add_edge("ugly", "bad")
pgm.add_edge("confused", "bad")
pgm.render()
plt.show(pgm.ax)
In [12]:
from matplotlib import rc
rc("font", family="serif", size=12)
rc("text", usetex=True)
import daft
# Instantiate the PGM.
pgm = daft.PGM([2.3, 2.05], origin=[0.3, 0.3])
# Hierarchical parameters.
pgm.add_node(daft.Node("alpha", r"$\alpha$", 0.5, 2, fixed=True))
pgm.add_node(daft.Node("beta", r"$\beta$", 1.5, 2))
# Latent variable.
pgm.add_node(daft.Node("w", r"$w_n$", 1, 1))
# Data.
pgm.add_node(daft.Node("x", r"$x_n$", 2, 1, observed=True))
# Add in the edges.
pgm.add_edge("alpha", "beta")
pgm.add_edge("beta", "w")
pgm.add_edge("w", "x")
pgm.add_edge("beta", "x")
# And a plate.
pgm.add_plate(daft.Plate([0.5, 0.5, 2, 1], label=r"$n = 1, \cdots, N$",
shift=-0.1))
# Render and save.
pgm.render()
plt.show(pgm.ax)
In [13]:
from matplotlib import rc
rc("font", family="serif", size=12)
rc("text", usetex=True)
import daft
# Colors.
p_color = {"ec": "#46a546"}
s_color = {"ec": "#f89406"}
pgm = daft.PGM([3.6, 3.5], origin=[0.7, 0])
n = daft.Node("phi", r"$\phi$", 1, 3, plot_params=s_color)
n.va = "baseline"
pgm.add_node(n)
pgm.add_node(daft.Node("speckle_coeff", r"$z_i$", 2, 3, plot_params=s_color))
pgm.add_node(daft.Node("speckle_img", r"$x_i$", 2, 2, plot_params=s_color))
pgm.add_node(daft.Node("spec", r"$s$", 4, 3, plot_params=p_color))
pgm.add_node(daft.Node("shape", r"$g$", 4, 2, plot_params=p_color))
pgm.add_node(daft.Node("planet_pos", r"$\mu_i$", 3, 3, plot_params=p_color))
pgm.add_node(daft.Node("planet_img", r"$p_i$", 3, 2, plot_params=p_color))
pgm.add_node(daft.Node("pixels", r"$y_i ^j$", 2.5, 1, observed=True))
# Edges.
pgm.add_edge("phi", "speckle_coeff")
pgm.add_edge("speckle_coeff", "speckle_img")
pgm.add_edge("speckle_img", "pixels")
pgm.add_edge("spec", "planet_img")
pgm.add_edge("shape", "planet_img")
pgm.add_edge("planet_pos", "planet_img")
pgm.add_edge("planet_img", "pixels")
# And a plate.
pgm.add_plate(daft.Plate([1.5, 0.2, 2, 3.2], label=r"exposure $i$",
shift=-0.1))
pgm.add_plate(daft.Plate([2, 0.5, 1, 1], label=r"pixel $j$",
shift=-0.1))
# Render and save.
pgm.render()
plt.show(pgm.ax)
In [33]:
%connect_info