from lib.handle import Handle from lorenz import Lorenz l = Lorenz(params=(40, 16, 4), size=3) h = Handle(l) l_123 = h.lyapunov_exponent_123() print(l_123) h.graph()
import numpy import pylab from numpy import asarray from lorenz import Lorenz l = Lorenz(10.0, 28.0, 8.0/3.0) dtraj, traj = [], [] DT, NSTEP = 0.01, 1000 dx, dy, dz = 0.0, 10.0, 10.0 x, y, z = 0.0, 10.0, 10.0 dtraj.append((dx, dy, dz)) traj.append((x, y, z)) for i in range(NSTEP): dx, dy, dz = l.diff(x, y, z, dx, dy, dz, DT) x, y, z = l.step(x, y, z, DT) dtraj.append((dx, dy, dz)) traj.append((x, y, z)) trajadj = [] xadj, yadj, zadj = 0.0, 10.0, 10.0 trajadj.append((xadj, yadj, zadj)) for i in range(NSTEP-1, 0-1, -1): x, y, z = traj[i] xadj, yadj, zadj = l.adj(x, y, z, xadj, yadj, zadj, DT) trajadj.append((xadj, yadj, zadj)) trajadj.reverse() aggr = (asarray(trajadj) * asarray(dtraj)).sum(axis=1)
from lorenz import Lorenz
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
A = Lorenz([-1,1,0])
u1 = A.solve(50,.01)
B = Lorenz([-1.001,1.001,0.001])
u2 = B.solve(50,.01)
print('---------------------------------------------------------------')
print('',u1,'\n',u2)
print('---------------------------------------------------------------')
print(u1[0][0],u2[0][0])
print(u1[-1][0],u2[-1][0])
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_xlabel("X Axis")
ax.set_ylabel("Y Axis")
ax.set_zlabel("Z Axis")
ax.set_title("Lorenz Attractor")
plt.plot(u1[:,0],u1[:,1],u1[:,2])
plt.plot(u2[:,0],u2[:,1],u2[:,2])
plt.show()
import numpy as np
import pickle
from lorenz import Lorenz
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
""" Initialize lorenz object by loading parameters from the training data file """
f = open("learning_algorithm2_training_data", "rb")
d = pickle.load(f)
sigma = d['sigma']
b = d['b']
r = d['r']
lrz = Lorenz(sigma, b, r)
lrz.X = d['X']
lrz.U = d['U']
"""
check robustness of trained control
generates n trajectories and store their start and end state
if the end state lies within a ball of radius 0.14 of the desired state,
control objective is achieved and documented as a 1 in the task. otherwise it is documented as 0.
sum of all the tasks divided by number of tasks gives the accuracy of the learning algorithm
"""
m = 1000 # number of trajectories to generate for checking accuracy of learned algorithm
n = 1000 # number of time steps for each trajectory
lrz.dt = 0.01 # set default time step to 0.01
xstart = np.zeros((m, 3)) # stores the initial state of the n trajectories
xend = np.zeros((m, 3)) # stores the final state of the n trajectories
task = np.zeros(
(m, 1), dtype=float
) # for each trajectory task stores 1 (resp. 0) for control objective
# (resp. not) achieved
from lorenz import Lorenz
from mpl_toolkits.mplot3d import Axes3D
import pickle
import matplotlib.pyplot as plt
""" Initialize lorenz object by loading parameters from the training data file """
f = open("learning_algorithm2_training_data", "rb")
d = pickle.load(f)
sigma = d['sigma']
b = d['b']
r = d['r']
lrz = Lorenz(sigma, b, r)
lrz.X = d['X']
lrz.U = d['U']
""" Initialize lorenz object state and compute trajectories with learning based control, lyapunov based control,
and without any control """
n = 6000 # number of time steps
lrz.state = [-4, -4, -1]
y_l, u_l, t_l = lrz.trajectory(n, 0)
lrz.state = [-4, -4, -1]
y_m, u_m, t_m = lrz.trajectory(n, 1)
lrz.state = [-4, -4, -1]
y_wc, t_wc = lrz.trajectory_no_control(n)
""" trajectory visualization """
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(111, projection='3d')
ax.plot(y_wc[:, 0],
y_wc[:, 1],
y_wc[:, 2],
'r',
linewidth=2,
label="uncontrolled trajectory")
import numpy
import pylab
from numpy import asarray
from lorenz import Lorenz
l = Lorenz(10.0, 28.0, 8.0/3.0)
DT, NSTEP = 0.01, 100
delta = 0.1
deltas = []
grads = []
for i in range(5):
dtraj = []
traj0 = []
traj1 = []
dx, dy, dz = 0.0, 10.0, 10.0
x0, y0, z0 = 0.0, 10.0, 10.0
x1, y1, z1 = x0 + delta * dx, y0 + delta * dy, z0 + delta * dz
dtraj.append((dx, dy, dz))
traj0.append((x0, y0, z0))
traj1.append((x1, y1, z1))
for i in range(NSTEP):
dx, dy, dz = l.diff(x0, y0, z0, dx, dy, dz, DT)
x0, y0, z0 = l.step(x0, y0, z0, DT)
x1, y1, z1 = l.step(x1, y1, z1, DT)
dtraj.append((dx, dy, dz))
traj0.append((x0, y0, z0))
traj1.append((x1, y1, z1))
from lorenz import Lorenz sigma = 10 rho = 28 beta = 8/3 L1 = Lorenz([-1,1,0],sigma,rho,beta) u1 = L1.solve(50,.01) L2 = Lorenz([-1.001,1.001,.001],sigma,rho,beta) u2 = L2.solve(50,.01) print(u1[0,0],u2[0,0]) print(u1[-1,0],u2[-1,0]) print(L1.df(2)) print(L1.test(u1))
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
from lorenz import Lorenz
import pickle
sigma = 10
b = 8 / 3
r = 1.5
lrz = Lorenz(sigma, b, r) # initialize lorenz object with given parameters
n_samples = 1000 # set number of training samples
lrz.X, lrz.U = np.zeros((n_samples, 3)), np.zeros(
(n_samples, 1)) # initialize training data to 0
""" Training
randomly initialize the state of the lorenz object and set lrz.X[i, :] to the initial state
lorenz object takes one step with -ve control and gets reward r1
reset the lorenz state back to starting state and take another step with +ve control which gives reward r2
Set policy lrz.U[i, 0] to -1 or 1 depending upon which policy maximizes reward
"""
for i in range(n_samples):
lrz.X[i, :] = lrz.reset()
lrz.step(-lrz.max_control)
r1 = lrz.reward()
lrz.state = lrz.X[i, :]
lrz.step(lrz.max_control)
r2 = lrz.reward()
lrz.U[i, 0] = 2 * np.argmax([r1, r2]) - 1
data = {
'sigma': sigma,
import numpy
import pylab
from numpy import asarray
from lorenz import Lorenz
l = Lorenz(10.0, 28.0, 8.0/3.0)
DT, NSTEP, NITER, STEP = 0.01, 1000, 100, 1.0E-11
ctrl = [0] * (NSTEP + 1)
obj0 = 1.0E+18
for iiter in range(NITER):
traj = []
x, y, z = 0.0, 10.0, 10.0
traj.append((x, y, z))
for i in range(NSTEP):
x += ctrl[i]
x, y, z = l.step(x, y, z, DT)
traj.append((x, y, z))
# obj = (asarray(traj)[int(NSTEP/2):,:]**2).sum()
obj = (x+1)**2 + (y+1)**2 + (z-20)**2
# if iiter % 100 == 0 or iiter == NITER - 1:
# t = asarray(traj[int(NSTEP/2):])
# pylab.figure()
# pylab.subplot(2,2,1)
# pylab.plot(t[:,0], t[:,1])
# pylab.xlabel('x'); pylab.ylabel('y')
# pylab.subplot(2,2,2)
import numpy
import pylab
from lorenz import Lorenz
l = Lorenz(10.0, 28.0, 8.0/3.0)
traj = []
DT, NSTEP = 0.01, 10000
x, y, z = 0.0, 10.0, 10.0
traj.append((x, y, z))
for i in range(NSTEP):
x, y, z = l.step(x, y, z, DT)
traj.append((x, y, z))
traj = numpy.asarray(traj)
pylab.subplot(2,2,1)
pylab.plot(traj[:,0], traj[:,1])
pylab.xlabel('x'); pylab.ylabel('y')
pylab.subplot(2,2,2)
pylab.plot(traj[:,0], traj[:,2])
pylab.xlabel('x'); pylab.ylabel('z')
pylab.subplot(2,2,3)
pylab.plot(traj[:,1], traj[:,2])
pylab.xlabel('y'); pylab.ylabel('z')
