def infinity_loss(Domain, Start):
    # Set Method
    Method = HeunEuler(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-3)

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-10)
    Term = Termination(MaxIter=25000,
                       Tols=[(Domain.gap_rplus, 1e-6 * gap_0)],
                       verbose=False)
    Repo = Reporting(Requests=[Domain.gap_rplus, 'Data', Domain.F])
    Misc = Miscellaneous(Timer=False)
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Start Solver
    SOI_Results = Solve(Start, Method, Domain, Options)

    # Record X_Star
    Data = SOI_Results.PermStorage['Data']
    dx = np.diff(Data, axis=0)
    F = SOI_Results.PermStorage[Domain.F][:-1]

    return -np.sum(F * dx)
示例#2
0
def Demo():

    #__BLOOD_BANK__##################################################

    # Define Network and Domain
    Network = CreateRandomNetwork(nC=2, nB=2, nD=2, nR=2, seed=0)
    Domain = BloodBank(Network=Network, alpha=2)

    # Set Method
    Method = CashKarp(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-6)

    # Initialize Starting Point
    Start = np.zeros(Domain.Dim)

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-10)
    Term = Termination(MaxIter=25000, Tols=[(Domain.gap_rplus, 1e-6 * gap_0)])
    Repo = Reporting(
        Requests=[Domain.gap_rplus, 'Step', 'F Evaluations', 'Projections'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    BloodBank_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, BloodBank_Results, Method, toc)
示例#3
0
def Demo():

    # __MACHINE_LEARNING_NETWORK____#################################################

    # Define Domain
    Network = CreateRandomNetwork()
    Domain = MLN(Network)

    # Set Method
    Method = Euler(Domain=Domain,FixStep=True,P=BoxProjection(lo=Domain.los,hi=Domain.his))

    # Set Options
    Term = Termination(MaxIter=500)
    Repo = Reporting(Requests=['Step', 'F Evaluations',
                               'Projections','Data'])
    Misc = Miscellaneous()
    Init = Initialization(Step=-1e-3)
    Options = DescentOptions(Init,Term,Repo,Misc)

    # Initialize Starting Point
    Start = np.random.rand(Domain.dim)*(Domain.his-Domain.los) + Domain.los
    Start[20:22] = [-.5,.5]
    Start[22:24] = [.5,.5]
    Start[24:26] = [.5,.5]
    Start[26:28] = [1.,0.]
    Start[28:32] = [-.5,-.25,-.75,-.5]

    # Print Stats
    PrintSimStats(Domain,Method,Options)

    # Start Solver
    tic = time.time()
    MLN_Results = Solve(Start,Method,Domain,Options)  # Use same Start
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options,MLN_Results,Method,toc)

    ########################################################
    # Animate Network
    ########################################################

    # Construct MP4 Writer
    fps = 5
    FFMpegWriter = animation.writers['ffmpeg']
    metadata = dict(title='MLN', artist='Matplotlib')
    writer = FFMpegWriter(fps=fps, metadata=metadata)

    # Collect Frames
    Frames = MLN_Results.PermStorage['Data'][::fps]

    # Save Animation to File
    fig, ax = plt.subplots()
    MLN_ani = animation.FuncAnimation(fig, Domain.UpdateVisual,
                                      init_func=Domain.InitVisual,
                                      frames=len(Frames),
                                      fargs=(ax, Frames))
    MLN_ani.save('MLN.mp4', writer=writer)
def Demo():

    #__LIENARD_SYSTEM__##################################################

    # Define Network and Domain
    Domain = Lienard()

    # Set Method
    Method = HeunEuler_LEGS(Domain=Domain, Delta0=1e-5)

    # Set Options
    Init = Initialization(Step=1e-5)
    Term = Termination(MaxIter=5e4)
    Repo = Reporting(Requests=['Data', 'Step'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)
    args = (Method, Domain, Options)
    sim = Solve

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Construct grid
    grid = [np.array([-2.5, 2.5, 13])] * 2
    grid = ListONP2NP(grid)
    grid = aug_grid(grid)
    Dinv = np.diag(1. / grid[:, 3])
    r = 1.1 * max(grid[:, 3])

    # Compute Results
    results = MCT(sim,
                  args,
                  grid,
                  nodes=8,
                  parallel=True,
                  limit=5,
                  AVG=-1,
                  eta_1=1.2,
                  eta_2=.95,
                  eps=1.,
                  L=8,
                  q=2,
                  r=r,
                  Dinv=Dinv)
    ref, data, p, i, avg, bndry_ids, starts = results

    # Plot BoAs
    figBoA, axBoA = plotBoA(ref, data, grid, wcolor=True, wscatter=True)

    # Plot Probablity Distribution
    figP, axP = plotDistribution(p, grid)
示例#5
0
def Demo():

    # __APPROXIMATE_LINEAR_FIELD__##############################################

    # Load Dummy Data
    X = np.random.rand(1000, 2) * 2 - 1
    scale = np.array([0.8, 1.2])
    y = 0.5 * np.sum(scale * X**2, axis=1)

    # Construct Field
    ALF = ApproxLF(X=X, dy=y, eps=1e-8)

    # Set Method
    # Method = Euler(Domain=ALF,FixStep=True)
    Method = HeunEuler(Domain=ALF, Delta0=1e-2)

    # Initialize Starting Field
    A = np.array([[0, 1], [-1, 0]])
    # A = np.eye(LF.XDim)
    # A = np.random.rand(LF.XDim,LF.XDim)
    # A = np.array([[5,0.],[0.,5]])
    b = np.zeros(ALF.XDim)
    Start = np.hstack([A.flatten(), b])
    print(Start)

    # Set Options
    Init = Initialization(Step=-1.0)
    Term = Termination(MaxIter=1000)  #,Tols=[(LF.error,1e-10)])
    Repo = Reporting(Requests=[ALF.error, 'Step', 'F Evaluations', 'Data'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(ALF, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, ALF, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    error = np.asarray(Results.PermStorage[ALF.error])
    params = Results.PermStorage['Data'][-1]

    A, b = ALF.UnpackFieldParams(params)

    print(A)
    print(b)
    print(error[-1])
def Demo():

    # __CONSTRAINED_OPTIMIZATION__##############################################

    # Define Domain: f(x) = x_1 + 2*x_2 - 1
    Domain = NewDomain(F=lambda x: np.array([1, 2]), Dim=2)
    Domain.Min = 0.
    Domain.f_Error = lambda x: x[0] + 2 * x[1] - 1 - Domain.Min

    # Define Polytope Constraints: Gx<=h & Ax=b
    G = -np.eye(Domain.Dim)
    h = np.zeros(Domain.Dim)
    A = np.ones((1, Domain.Dim))
    b = 1.

    # Set Method
    P = PolytopeProjection(G=G, h=h, A=A, b=b)
    Method = Euler(Domain=Domain, FixStep=True, P=P)

    # Initialize Starting Point
    Start = np.array([0, 1])

    # Set Options
    Init = Initialization(Step=-0.1)
    Term = Termination(MaxIter=1000, Tols=[(Domain.f_Error, 1e-6)])
    Repo = Reporting(Requests=[
        Domain.f_Error, 'Step', 'F Evaluations', 'Projections', 'Data'
    ])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    error = np.asarray(Results.PermStorage[Domain.f_Error])

    plt.plot(error, '-o', lw=2)
    plt.title('Projected Subgradient')
    plt.xlabel('Iterations')
    plt.ylabel('Objective error')
    plt.ylim([-.1, 1.1])
    plt.show()
示例#7
0
def Demo():

    #__Gaussian_Mixture_GAN__#############################################

    # Define Network and Domain
    Domain = GMGAN(dyn='FCC')

    # Set Method
    # Method = Euler_LEGS(Domain=Domain,FixStep=True,NTopLEs=2)
    # Method = HeunEuler_LEGS(Domain=Domain,Delta0=1e-5,NTopLEs=2)
    # Method = CashKarp_LEGS(Domain=Domain,Delta0=1e-5,NTopLEs=2)
    # Method = HeunEuler(Domain=Domain,Delta0=1e-5)
    Method = HeunEuler_PhaseSpace(Domain=Domain, Delta0=1e-3, MaxStep=-.5)
    # Method = Euler(Domain=Domain,FixStep=True)

    # Initialize Starting Point
    Start = Domain.get_weights()

    # Set Options
    Init = Initialization(Step=-1.)
    Term = Termination(MaxIter=3e2)
    # Repo = Reporting(Requests=['Step','Data','Lyapunov',Domain.gap])
    Repo = Reporting(Requests=['Step'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    GMGAN_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, GMGAN_Results, Method, toc)

    Domain.set_weights(GMGAN_Results.TempStorage['Data'][-1])
    fig, ax = Domain.visualize_dist()
    plt.savefig('gmgan_test.png')

    Steps = np.array(GMGAN_Results.PermStorage['Step'])
    plt.clf()
    plt.semilogy(-Steps)
    plt.savefig('steps.png')

    embed()
示例#8
0
def Demo():

    #__CLOUD_SERVICES__##################################################

    # Define Network and Domain
    Network = CreateNetworkExample(ex=5)
    Domain = CloudServices(Network=Network, gap_alpha=2)

    # Set Method
    eps = 1e-2
    Method = HeunEuler_LEGS(Domain=Domain, P=BoxProjection(lo=eps), Delta0=1e0)

    # Initialize Starting Point
    Start = np.ones(Domain.Dim)

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-3)
    Term = Termination(MaxIter=1e5, Tols=[(Domain.gap_rplus, 1e-12 * gap_0)])
    Repo = Reporting(Requests=[
        Domain.gap_rplus, 'Step', 'F Evaluations', 'Projections', 'Data',
        Domain.eig_stats, 'Lyapunov'
    ])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    CloudServices_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, CloudServices_Results, Method, toc)

    x = CloudServices_Results.PermStorage['Data'][-1]
    print('p,q,Q,pi,Nash?')
    print(x[:Domain.Dim // 2])
    print(x[Domain.Dim // 2:])
    print(Domain.Demand(x)[0])
    print(Domain.CloudProfits(x))
    print(all(Domain.Nash(x)[0]))
示例#9
0
def Demo():

    #__LIENARD_SYSTEM__##################################################

    # Define Network and Domain
    Domain = Lienard()

    # Set Method
    Method = Euler_LEGS(Domain=Domain, FixStep=True, NTopLEs=2)
    # Method = HeunEuler_LEGS(Domain=Domain,Delta0=1e-5,NTopLEs=2)
    # Method = CashKarp_LEGS(Domain=Domain,Delta0=1e-5,NTopLEs=2)

    # Initialize Starting Point
    Start = np.array([1.5, 0])

    # Set Options
    Init = Initialization(Step=1e-3)
    Term = Termination(MaxIter=1e5, Tols=[(Domain.gap, 1e-3)])
    Repo = Reporting(Requests=['Step', 'Data', 'Lyapunov', Domain.gap])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Lienard_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Lienard_Results, Method, toc)

    # Plot Lyapunov Exponents
    plt.plot(Lienard_Results.PermStorage['Lyapunov'])
    plt.show()

    # Plot System Trajectory
    data = ListONP2NP(Lienard_Results.PermStorage['Data'])
    plt.plot(data[:, 0], data[:, 1])
    ax = plt.gca()
    ax.set_xlim([-2.5, 2.5])
    ax.set_ylim([-2.5, 2.5])
    ax.set_aspect('equal')
    plt.show()
示例#10
0
def score_matrixfac(train, test, mask, step=1e-5, iters=100, k=500):
    # Define Domain
    n, d = train.shape
    sh_P = (n, k)
    sh_Q = (d, k)
    Domain = MatrixFactorization(Data=train, sh_P=sh_P, sh_Q=sh_Q)

    # Set Method
    # Method = Euler(Domain=Domain,FixStep=True)
    Method = HeunEuler(Domain=Domain, Delta0=1e-1, MinStep=1e-7, MaxStep=1e-2)

    # Initialize Starting Point
    globalmean = train.sum() / train.nnz
    scale = np.sqrt(globalmean / k)
    # P = np.random.rand(n,k)
    # Q = np.random.rand(d,k)
    P = scale * np.ones(sh_P)
    Q = scale * np.ones(sh_Q)
    Start = np.hstack((P.flatten(), Q.flatten()))

    # Set Options
    Init = Initialization(Step=step)
    Term = Termination(MaxIter=iters)
    Repo = Reporting(Requests=['Step', 'F Evaluations'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    # Retrieve result
    parameters = np.asarray(Results.TempStorage['Data'][-1])
    pred = Domain.predict(parameters)

    return rmse(pred, test, mask)
示例#11
0
def score_svdmethod(train,
                    test,
                    mask,
                    tau=6e3,
                    step=1.9,
                    fixstep=True,
                    iters=250):
    # Define Domain
    Domain = SVDMethod(Data=train, tau=tau)

    # Set Method
    # Method = Euler(Domain=Domain,FixStep=fixstep)
    Method = HeunEuler(Domain=Domain, Delta0=1e2, MinStep=1e0, MaxStep=1e3)

    # Initialize Starting Point
    # globalmean = train.sum()/train.nnz
    # Start = globalmean*np.ones(train.shape)
    Start = np.zeros(train.shape).flatten()

    # Set Options
    Init = Initialization(Step=step)
    Term = Termination(MaxIter=iters, Tols=[(Domain.rel_error, 0.2)])
    Repo = Reporting(Requests=[Domain.rel_error, 'Step', 'F Evaluations'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    # Retrieve result
    Y = np.asarray(Results.TempStorage['Data'][-1]).reshape(train.shape)
    pred = Domain.shrink(Y, Domain.tau)

    return rmse(pred, test, mask), Results.PermStorage[Domain.rel_error]
示例#12
0
def Demo():

    #__SUPPLY_CHAIN__##################################################

    # Define Network and Domain
    Network = CreateRandomNetwork(I=2, Nm=2, Nd=2, Nr=1, seed=0)
    Domain = SupplyChain(Network=Network, alpha=2)

    # Set Method
    Method = CashKarp(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-5)

    # Initialize Starting Point
    x = 10 * np.ones(np.product(Domain.x_shape))
    gam = np.ones(np.sum([np.product(g) for g in Domain.gam_shapes]))
    lam = np.zeros(np.sum([np.product(l) for l in Domain.lam_shapes]))
    Start = np.concatenate((x, gam, lam))

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-10)
    Term = Termination(MaxIter=25000, Tols=[(Domain.gap_rplus, 1e-3 * gap_0)])
    Repo = Reporting(Requests=[
        Domain.gap_rplus, 'Step', 'F Evaluations', 'Projections', 'Data'
    ])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    SupplyChain_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, SupplyChain_Results, Method, toc)
示例#13
0
def score_mixturemean(train, test, mask, step=-1e-3, iters=100):
    # Define Domain
    Domain = MixtureMean(Data=train)

    # Set Method
    Method = Euler(Domain=Domain, P=BoxProjection(lo=0., hi=1.))
    # Method = Euler(Domain=Domain,P=EntropicProjection())
    # Method = HeunEuler(Domain=Domain,P=EntropicProjection(),Delta0=1e-5,
    #                    MinStep=-1e-1,MaxStep=-1e-4)

    # Initialize Starting Point
    # Start = np.array([.452,.548])
    Start = np.array([.452])

    # Set Options
    Init = Initialization(Step=step)
    Term = Termination(MaxIter=iters)
    Repo = Reporting(Requests=['Step', 'F Evaluations'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    # Retrieve result
    parameters = np.asarray(Results.TempStorage['Data'][-1])
    pred = Domain.predict(parameters)

    return rmse(pred, test, mask)
示例#14
0
def Demo():

    #__MHPH__##################################################

    trials = range(1000,8000+1,2000)
    MHPH_Results = [[] for i in trials]

    for n in trials:

        #Define Dimension and Domain
        Domain = MHPH(Dim=n)

        # Set Method
        Method = HeunEuler(Domain=Domain,P=EntropicProjection(),Delta0=1e-1)
        # Method = RipCurl(Domain=Domain,P=EntropicProjection(),factor=0.1,FixStep=True)

        # Set Options
        Init = Initialization(Step=-1)
        Term = Termination(MaxIter=100,Tols=[[Domain.gap_simplex,1e-3]])
        Repo = Reporting(Requests=[Domain.gap_simplex])
        Misc = Miscellaneous()
        Options = DescentOptions(Init,Term,Repo,Misc)

        #Initialize Starting Point
        Start = np.ones(Domain.Dim)/np.double(Domain.Dim)

        # Print Stats
        PrintSimStats(Domain,Method,Options)

        tic = time.time()
        ind = int(n/2000)-4
        MHPH_Results[ind] = Solve(Start,Method,Domain,Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options,MHPH_Results[ind],Method,toc)
def Demo():

    #__SUPPLY_CHAIN__##################################################

    #############################################################
    # Example 1 from Nagurney's Paper
    #############################################################

    # Define Network and Domain
    Network = CreateNetworkExample(ex=1)
    Domain = SupplyChain(Network=Network, alpha=2)

    # Set Method
    Method = ABEuler(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-2)

    # Initialize Starting Point
    x = 10 * np.ones(np.product(Domain.x_shape))
    gam = np.ones(np.sum([np.product(g) for g in Domain.gam_shapes]))
    lam = np.zeros(np.sum([np.product(l) for l in Domain.lam_shapes]))
    Start = np.concatenate((x, gam, lam))

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-10)
    Term = Termination(MaxIter=25000, Tols=[(Domain.gap_rplus, 1e-3 * gap_0)])
    Repo = Reporting(Requests=[
        Domain.gap_rplus, 'Step', 'F Evaluations', 'Projections', 'Data'
    ])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    SupplyChain_Results_Phase1 = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, SupplyChain_Results_Phase1, Method, toc)

    #############################################################
    # Increased Demand of Firm 2's Product
    #############################################################

    # Define Network and Domain
    Network = CreateNetworkExample(ex=2)
    Domain = SupplyChain(Network=Network, alpha=2)

    # Set Method
    Method = ABEuler(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-2)

    # Initialize Starting Point
    Start = SupplyChain_Results_Phase1.PermStorage['Data'][-1]

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-10)
    Term = Termination(MaxIter=25000, Tols=[(Domain.gap_rplus, 1e-3 * gap_0)])
    Repo = Reporting(Requests=[
        Domain.gap_rplus, 'Step', 'F Evaluations', 'Projections', 'Data'
    ])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    SupplyChain_Results_Phase2 = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, SupplyChain_Results_Phase2, Method, toc)

    ########################################################
    # Animate Network
    ########################################################

    # Construct MP4 Writer
    fps = 15
    FFMpegWriter = animation.writers['ffmpeg']
    metadata = dict(title='SupplyChain', artist='Matplotlib')
    writer = FFMpegWriter(fps=fps, metadata=metadata)

    # Collect Frames
    frame_skip = 5
    freeze = 5
    Dyn_1 = SupplyChain_Results_Phase1.PermStorage['Data']
    Frz_1 = [Dyn_1[-1]] * fps * frame_skip * freeze
    Dyn_2 = SupplyChain_Results_Phase2.PermStorage['Data']
    Frz_2 = [Dyn_2[-1]] * fps * frame_skip * freeze
    Frames = np.concatenate((Dyn_1, Frz_1, Dyn_2, Frz_2), axis=0)[::frame_skip]

    # Normalize Colormap by Flow at each Network Level
    Domain.FlowNormalizeColormap(Frames, cm.rainbow)

    # Mark Annotations
    t1 = 0
    t2 = t1 + len(SupplyChain_Results_Phase1.PermStorage['Data']) // frame_skip
    t3 = t2 + fps * freeze
    t4 = t3 + len(SupplyChain_Results_Phase2.PermStorage['Data']) // frame_skip
    Dyn_1_ann = 'Control Network\n(Equilibrating)'
    Frz_1_ann = 'Control Network\n(Converged)'
    Dyn_2_ann = 'Market Increases Demand for Firm 2' 's Product\n(Equilibrating)'
    Frz_2_ann = 'Market Increases Demand for Firm 2' 's Product\n(Converged)'
    anns = sorted([(t1, plt.title, Dyn_1_ann), (t2, plt.title, Frz_1_ann),
                   (t3, plt.title, Dyn_2_ann), (t4, plt.title, Frz_2_ann)],
                  key=lambda x: x[0],
                  reverse=True)

    # Save Animation to File
    fig, ax = plt.subplots()
    SupplyChain_ani = animation.FuncAnimation(fig,
                                              Domain.UpdateVisual,
                                              init_func=Domain.InitVisual,
                                              frames=len(Frames),
                                              fargs=(ax, Frames, anns),
                                              blit=True)
    SupplyChain_ani.save('Videos/SupplyChain.mp4', writer=writer)
示例#16
0
def Demo():

    #__SPHERE__##################################################

    # Define Dimension and Domain
    Domain = MonotoneCycle()

    # Set Method
    MethodEuler = Euler(Domain=Domain,P=IdentityProjection(),FixStep=True)
    MethodEG = EG(Domain=Domain,P=IdentityProjection(),FixStep=True)

    # Set Options
    Init = Initialization(Step=-1e-1)
    Term = Termination(MaxIter=100)
    Repo = Reporting(Requests=['Data'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init,Term,Repo,Misc)

    # Initialize Starting Point
    Start = np.ones(Domain.Dim)

    # Print Stats
    PrintSimStats(Domain,MethodEuler,Options)

    # Start Solver
    tic = time.time()
    Euler_Results = Solve(Start,MethodEuler,Domain,Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options,Euler_Results,MethodEuler,toc)

    # Print Stats
    PrintSimStats(Domain,MethodEG,Options)

    # Start Solver
    tic = time.time()
    EG_Results = Solve(Start,MethodEG,Domain,Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options,EG_Results,MethodEG,toc)

    data_Euler = ListONP2NP(Euler_Results.PermStorage['Data'])
    data_EG = ListONP2NP(EG_Results.PermStorage['Data'])
    

    X, Y = np.meshgrid(np.arange(-2.5, 2.5, .2), np.arange(-2.5, 2.5, .2))
    U = np.zeros_like(X)
    V = np.zeros_like(Y)
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            vec = -Domain.F([X[i,j],Y[i,j]])
            U[i,j] = vec[0]
            V[i,j] = vec[1]

    # plt.figure()
    # plt.title('Arrows scale with plot width, not view')
    # Q = plt.quiver(X, Y, U, V, units='width')
    # qk = plt.quiverkey(Q, 0.9, 0.9, 2, r'$2 \frac{m}{s}$', labelpos='E',
    #                    coordinates='figure')

    fig = plt.figure()
    ax = fig.add_axes([0.1, 0.1, 0.6, 0.75])
    plt.title("Extragradient vs Simultaneous Gradient Descent")
    Q = plt.quiver(X[::3, ::3], Y[::3, ::3], U[::3, ::3], V[::3, ::3],
                   pivot='mid', units='inches')
    vec_Euler = -Domain.F(data_Euler[-1,:])
    vec_EG = -Domain.F(data_EG[-1,:])
    print(data_Euler[-1])
    print(vec_Euler)
    plt.quiver(data_Euler[-1][0], data_Euler[-1][1], vec_Euler[0], vec_Euler[1], pivot='mid', units='inches', color='b',
            headwidth=5)
    plt.quiver(data_EG[-1][0], data_EG[-1][1], vec_EG[0], vec_EG[1], pivot='mid', units='inches', color='r',
            headwidth=5)
    plt.scatter(X[::3, ::3], Y[::3, ::3], color='gray', s=5)
    plt.plot(data_Euler[:,0],data_Euler[:,1],'b',linewidth=5,label='Simultaneous\nGradient Descent')
    plt.plot(data_EG[:,0],data_EG[:,1],'r',linewidth=5,label='Extragradient')
    plt.plot([0],[0],linestyle="None",marker=(5,1,0),markersize=20,color='gold',label='Equilibrium')
    plt.axis([-2.5,2.5,-2.5,2.5])
    plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), borderaxespad=0.5)
    # plt.ion()
    # plt.show()
    plt.savefig('EGvsEuler.png')
示例#17
0
def Demo():

    #__SPHERE__##################################################

    # Define Dimension and Domain
    Domain = Sphere(Dim=100)

    # Set Method
    Method = HeunEuler(Domain=Domain, P=IdentityProjection(), Delta0=1e-2)

    # Set Options
    Init = Initialization(Step=-1e-1)
    Term = Termination(MaxIter=1000, Tols=[[Domain.f_Error, 1e-3]])
    Repo = Reporting(Requests=[Domain.f_Error])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Initialize Starting Point
    Start = 100 * np.ones(Domain.Dim)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    SPHERE_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, SPHERE_Results, Method, toc)

    #__KOJIMA-SHINDO__##################################################

    # Define Dimension and Domain
    Domain = KojimaShindo()

    # Set Method
    Method = HeunEuler(Domain=Domain, P=EntropicProjection(), Delta0=1e-1)

    # Set Options
    Init = Initialization(Step=-1e-1)
    Term = Termination(MaxIter=1000, Tols=[[Domain.gap_simplex, 1e-3]])
    Repo = Reporting(Requests=[Domain.gap_simplex])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Initialize Starting Point
    Start = np.ones(Domain.Dim) / np.double(Domain.Dim)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    KS_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, KS_Results, Method, toc)

    #__WATSON__##################################################

    trials = xrange(10)
    WAT_Results = [[] for i in trials]

    for p in trials:

        #Define Dimension and Domain
        Domain = Watson(Pos=p)

        # Set Method
        Method = HeunEuler(Domain=Domain, P=EntropicProjection(), Delta0=1e-1)

        # Set Options
        Init = Initialization(Step=-1e-1)
        Term = Termination(MaxIter=1000, Tols=[[Domain.gap_simplex, 1e-3]])
        Repo = Reporting(Requests=[Domain.gap_simplex])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        #Initialize Starting Point
        Start = np.ones(Domain.Dim) / np.double(Domain.Dim)

        # Print Stats
        PrintSimStats(Domain, Method, Options)

        tic = time.time()
        WAT_Results[p] = Solve(Start, Method, Domain, Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options, WAT_Results[p], Method, toc)

    #__SUN__##################################################

    trials = xrange(8000, 10000 + 1, 2000)
    Sun_Results = [[] for i in trials]

    for n in trials:

        #Define Dimension and Domain
        Domain = Sun(Dim=n)

        # Set Method
        Method = HeunEuler(Domain=Domain, P=EntropicProjection(), Delta0=1e-1)

        # Set Options
        Init = Initialization(Step=-1e-1)
        Term = Termination(MaxIter=1000, Tols=[[Domain.gap_simplex, 1e-3]])
        Repo = Reporting(Requests=[Domain.gap_simplex])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        #Initialize Starting Point
        Start = np.ones(Domain.Dim) / np.double(Domain.Dim)

        # Print Stats
        PrintSimStats(Domain, Method, Options)

        tic = time.time()
        ind = n / 2000 - 4
        Sun_Results[ind] = Solve(Start, Method, Domain, Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options, Sun_Results[ind], Method, toc)
示例#18
0
def Demo_NdLQGAN(root='lqganresults/', Dims=None, Algorithms=None, File=None):
    # Dims = [1]
    Dims = [1,2]
    Nmusigmas = 10
    Lstarts = 10
    Algorithms = dict(zip(['Fsim','EG','Fcon','Freg','Feg','Fcc'],range(6)))
    # Algorithms = dict(zip(['Fcc','Fsim','Feg','Fcon','Freg','EG'],range(6)))
    # Algorithms = dict(zip(['Fcc','Feg','Freg'],range(3)))
    # Algorithms = dict(zip(['Fcc','Feg'],range(2)))
    # Algorithms = dict(zip(['Fcc','Feg','Fccprime','Fegprime'],range(4)))
    # Algorithms = dict(zip(['Fccprime','Fegprime'],range(2)))
    # Algorithms = dict(zip(['Fcc'],range(1)))
    # Algorithms = ['Fcon']
    # Algorithms = dict(zip(['Fcc','Feg','Fcon','Freg','Falt','Funr'],range(6)))

    Iters = 10000

    data = np.empty((len(Dims),Nmusigmas,Lstarts,len(Algorithms),10))

    for i, dim in enumerate(tqdm.tqdm(Dims)):
        Domain = LQGAN(dim=dim, var_only=True)

        # Dimensionality
        s = Domain.s
        pdim = Domain.Dim

        # Set Constraints
        loA = -np.inf*np.ones((dim,dim))
        loA[range(dim),range(dim)] = 1e-2
        lo = np.hstack(([-np.inf]*(dim+s), loA[np.tril_indices(dim)], [-np.inf]*dim))
        P = BoxProjection(lo=lo)

        for musigma in tqdm.tqdm(range(Nmusigmas)):
            # Reset LQGAN to random mu and Sigma
            mu, Sigma = rand_mu_Sigma(dim=dim)
            # print(Sigma.flatten().item())
            mu = np.zeros(dim)
            # Sigma = np.array([[1]])
            # Sigma = np.diag(np.random.rand(dim)*10+1.)
            lams = np.linalg.eigvals(Sigma)
            K = lams.max()/lams.min()
            # print(np.linalg.eigvals(Sigma))
            Domain.set_mu_sigma(mu=mu,sigma=Sigma)
            # print(mu,Sigma)

            for l in tqdm.tqdm(range(Lstarts)):
                # Intialize G and D variables to random starting point
                # should initialize A to square root of random Sigma
                # Start = P.P(10*np.random.rand(pdim)-5.)
                Start = np.zeros(pdim)
                Start[:s] = np.random.rand(s)*10-5
                Start[s:s+dim] = 0.  # set w_1 to zero
                Start[-dim:] = mu  # set b to mu
                Start[-dim-s:-dim] = np.linalg.cholesky(rand_mu_Sigma(dim=dim)[1])[np.tril_indices(dim)]
                Start = P.P(Start)

                # Calculate Initial KL and Euclidean distance
                KL_0 = Domain.dist_KL(Start)
                Euc_0 = Domain.dist_Euclidean(Start)
                norm_F_0 = Domain.norm_F(Start)
                # print(KL_0,Euc_0,norm_F_0)

                for j, alg in enumerate(tqdm.tqdm(Algorithms)):

                    # Step = -1e-3
                    if alg == 'EG':
                        Step = -1e-3
                        Domain.preconditioner = 'Fsim'
                        Method = EG(Domain=Domain,FixStep=True,P=P)
                    elif alg == 'Fsim':
                        Step = -1e-4
                        Domain.preconditioner='Fsim'
                        Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-3,P=P,MinStep=-1e-2)
                        # Method = Euler(Domain=Domain,FixStep=True,P=P)
                    elif alg == 'Fcon':
                        Step = -1e-4
                        Domain.preconditioner = alg
                        Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-3,P=P,MinStep=-1e-2)
                        # Method = Euler(Domain=Domain,FixStep=True,P=P)
                    elif alg == 'Falt' or alg == 'Funr':
                        Step = -5e-3
                        Domain.preconditioner = alg
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-5,P=P)
                        Method = Euler(Domain=Domain,FixStep=True,P=P)
                    elif alg == 'Fccprime' or alg == 'Fegprime':
                        Step = -1e-1
                        Domain.preconditioner = alg
                        Method = Euler(Domain=Domain,FixStep=True,P=P)
                    else:
                        # Step = -1e-1
                        Step = -1e-4
                        Domain.preconditioner = alg
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-0,P=P,MinStep=-10.)  # for 2d+
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-2,P=P,MinStep=-1e-1) # 13 slow
                        Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-3,P=P,MinStep=-1e-2) # slow
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-1,P=P,MinStep=-1e-1) better
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-1,P=P,MinStep=-1e-10) slow
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-1,P=P,MinStep=-1e-2) best so far, Feg is not working well?
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-2,P=P,MinStep=-1e-2) ok
                        # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-2,P=P,MinStep=-1e-1)
                        # Delta0=1e-2,MinStep=-1e-1 for speed on 1d, scaled versions are surprisingly worse
                    
                    # Set Options
                    Init = Initialization(Step=Step)
                    Tols = [#(Domain.norm_F,1e-3*norm_F_0),
                            # (Domain.dist_KL,1e-3*KL_0),
                            (Domain.dist_Euclidean,1e-3*Euc_0),
                            (Domain.isNotNaNInf,False)]
                    Term = Termination(MaxIter=Iters,Tols=Tols,verbose=False)
                    Repo = Reporting(Requests=[Domain.norm_F, Domain.dist, 
                                               Domain.dist_KL, Domain.dist_Euclidean,
                                               Domain.isNotNaNInf])
                    # 'Step','Data',
                    Misc = Miscellaneous()
                    Options = DescentOptions(Init,Term,Repo,Misc)

                    # Start Solver
                    tic = time.time()
                    LQ_Results = Solve(Start,Method,Domain,Options)
                    toc = time.time() - tic

                    KL = LQ_Results.PermStorage[Domain.dist_KL][-1]
                    Euc = LQ_Results.PermStorage[Domain.dist_Euclidean][-1]
                    norm_F = LQ_Results.PermStorage[Domain.norm_F][-1]
                    # x = np.array(LQ_Results.PermStorage['Data'])
                    # Steps = np.array(LQ_Results.PermStorage['Step'])
                    runtime = toc
                    steps = LQ_Results.thisPermIndex
                    # embed()

                    data[i,musigma,l,j,:] = np.array([dim,musigma,Algorithms[alg],l,K,KL/KL_0,Euc/Euc_0,norm_F/norm_F_0,runtime,steps])
                    # embed()
            np.save(root+'results15.npy', data)
示例#19
0
def Demo_1dLQGAN(root='figures/'):
    ##############################################################################
    # Compre Trajectories Plot ###################################################
    ##############################################################################

    # Define Network and Domain
    dim = 1
    s = (dim**2+dim)//2
    mu = np.array([0])
    sig = np.array([[1]])

    np.set_printoptions(linewidth=200)

    # Set Constraints
    loA = -np.inf*np.ones((dim,dim))
    loA[range(dim),range(dim)] = 1e-2
    lo = np.hstack(([-np.inf]*(dim+s), loA[np.tril_indices(dim)], [-np.inf]*dim))
    P = BoxProjection(lo=lo)

    xoff = 0
    yoff = 0
    scale = 30

    datas = []
    dists = []
    methods = ['Fcc','Fsim','Feg','Fcon','Freg','EG','Falt','Funr']
    for method in methods:

        if method == 'EG':
            Step = -1e-2
            Iters = 10000
            Domain = LQGAN(mu=mu,sig=sig,preconditioner='Fsim')
            Method = EG(Domain=Domain,FixStep=True,P=P)
        elif method == 'Fsim':
            Step = -1e-3
            Iters = 100000
            Domain = LQGAN(mu=mu,sig=sig,preconditioner='Fsim')
            Method = Euler(Domain=Domain,FixStep=True,P=P)
            # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-5,MinStep=-1.,P=P)
        elif method == 'Fcon':
            Step = -1e-6
            # Iters = 2750
            Iters = 3000
            Domain = LQGAN(mu=mu,sig=sig,preconditioner=method)
            Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-5,P=P)
        elif method == 'Falt' or method == 'Funr':
            Step = -5e-3
            # Iters = 2750
            Iters = 10000
            Domain = LQGAN(mu=mu,sig=sig,preconditioner=method)
            # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-5,P=P)
            Method = Euler(Domain=Domain,FixStep=True,P=P)
        else:
            Step = -1e-5
            Iters = 10000
            Domain = LQGAN(mu=mu,sig=sig,preconditioner=method)
            Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-5,P=P)
        
        # Initialize Starting Point
        Start = np.array([50.,0.,30.,0.])

        # Set Options
        Init = Initialization(Step=Step)
        Term = Termination(MaxIter=Iters,Tols=[(Domain.dist_Euclidean,1e-4)])
        Repo = Reporting(Requests=['Step', 'F Evaluations',
                                   'Projections','Data',Domain.dist_Euclidean])
        Misc = Miscellaneous()
        Options = DescentOptions(Init,Term,Repo,Misc)

        # Print Stats
        PrintSimStats(Domain,Method,Options)

        # Start Solver
        tic = time.time()
        LQ_Results = Solve(Start,Method,Domain,Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options,LQ_Results,Method,toc)

        datas += [np.array(LQ_Results.PermStorage['Data'])]
        dists += [np.array(LQ_Results.PermStorage[Domain.dist_Euclidean])]

    X, Y = np.meshgrid(np.linspace(-2*scale + xoff, 2*scale + xoff, 21), np.arange(1e-2 + yoff, 4*scale + yoff, .2*scale))
    U = np.zeros_like(X)
    V = np.zeros_like(Y)
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            vec = -Domain._F(np.array([X[i,j],0.,Y[i,j],0.]))
            U[i,j] = vec[0]
            V[i,j] = vec[2]

    fs = 18
    fig = plt.figure()
    ax = fig.add_subplot(111)
    Q = plt.quiver(X[::3, ::3], Y[::3, ::3], U[::3, ::3], V[::3, ::3],
                   pivot='mid', units='inches')
    colors = ['r','c','b','k','g','m','gray','orange']
    methods = [r'$F_{cc}$',r'$F$',r'$F_{eg}$',r'$F_{con}$',r'$F_{reg}$',r'$EG$',r'$F_{alt}$',r'$F_{unr}$']
    for data, color, method in zip(datas,colors,methods):
        if method == 'EG' or method == 'Funr':
            ax.plot(data[:,0],data[:,2],'-.',color=color,label=method,zorder=0)
        else:
            ax.plot(data[:,0],data[:,2],color=color,label=method,zorder=0)
    ax.plot([data[0,0]],[data[0,2]],'k*')
    ax.plot(mu,sig[0],'*',color='gold')
    # ax.set_xlim([-2*scale + xoff,2*scale + xoff])
    # ax.set_ylim([-.1*scale + yoff,4*scale + yoff])
    ax.set_xlim([-60., 60.])
    ax.set_ylim([-.1*scale + yoff, 100.])
    ax.set_xlabel(r'$w_2$', fontsize=fs)
    ax.set_ylabel(r'$a$', fontsize=fs)
    for tick in ax.xaxis.get_major_ticks():
        tick.label.set_fontsize(14)
    for tick in ax.yaxis.get_major_ticks():
        tick.label.set_fontsize(14)
    plt.title('Trajectories for Various Equilibrium Algorithms', fontsize=16)
    # plt.legend(fontsize=fs, loc="upper left")

    fs = 24
    # locs = [(15,25),(-35,80),(0,40),(42.5,3.0),(20,2.5),(-30,35),(-40,20),(-20,20)]
    # locs = [(15,25),(-35,80),(2.5,40),(42.5,3.0),(20,2.5),(-45,45),(-42.5,5),(-22.5,5)]
    locs = [(15,25),(-35,75),(2.5,40),(42.5,3.0),(20,2.5),(-45,45),(-42.5,5),(-22.5,5)]
    for method,color,loc in zip(methods,colors,locs):
        ax.annotate(method, xy=loc, color=color, zorder=1, fontsize=fs,
                    bbox=dict(facecolor='white', edgecolor='white', pad=0.0))

    plt.savefig(root+'trajcomp.png',bbox_inches='tight')

    ##############################################################################
    # Euclidean Distance to Equilibrium vs Iterations ############################
    ##############################################################################

    # Old Version of Plot
    # # fig = plt.figure()
    # # ax = fig.add_subplot(111)
    # # colors = ['r','gray','b','k','g']
    # # for dist, color, method in zip(dists,colors,methods):
    # #     ax.plot(dist,color=color,label=method)
    # # ax.set_xlabel('Iterations')
    # # ax.set_ylabel('Distance to Equilibrium')
    # # plt.legend()
    # # plt.title('Iteration vs Distance to Equilibrium for Various Equilibrium Algorithms')
    # # plt.savefig('runtimecomp.png')

    # More Recent Version of Plot
    fig,(ax,ax2) = plt.subplots(1,2,sharey=True, facecolor='w')
    for dist, color, method in zip(dists,colors,methods):
        # if method == 'simGD':
        iters = np.arange(dist.shape[0])/1000
        # print(dist[:5])
        ax.plot(iters,dist,color=color,label=method)
        ax2.plot(iters,dist,color=color,label=method)
        # else:
        #     ax.plot(dist,color=color,label=method)
    ax.set_xlim(-.1,10)
    ax.set_xticks([0,2,4,6,8,10])
    ax2.set_xlim(50,100)
    ax.set_ylim(-5,95)
    ax2.set_ylim(-5,95)

    # hide the spines between ax and ax2
    ax.spines['right'].set_visible(False)
    ax2.spines['left'].set_visible(False)
    ax.yaxis.tick_left()
    ax.tick_params(labelright='off')
    ax2.yaxis.tick_right()
    ax2.set_xticks([75,100])

    d = .015 # how big to make the diagonal lines in axes coordinates
    # arguments to pass plot, just so we don't keep repeating them
    kwargs = dict(transform=ax.transAxes, color='k', clip_on=False)
    ax.plot((1-d,1+d), (-d,+d), **kwargs)
    ax.plot((1-d,1+d),(1-d,1+d), **kwargs)

    kwargs.update(transform=ax2.transAxes)  # switch to the bottom axes
    ax2.plot((-d,+d), (1-d,1+d), **kwargs)
    ax2.plot((-d,+d), (-d,+d), **kwargs)

    # ax.set_xlabel('Iterations')
    fig.text(0.5, 0.02, 'Thousand Iterations', ha='center', fontsize=12)
    ax.set_ylabel('Distance to Equilibrium',fontsize=12)
    # ax.legend()
    ax2.legend(fontsize=18)
    plt.suptitle('Iteration vs Distance to Equilibrium for Various Equilibrium Algorithms')
    plt.savefig(root+'runtimecomp.png')

    ##############################################################################
    # Individual Trajectory Plots ################################################
    ##############################################################################

    # Set Constraints
    loA = -np.inf*np.ones((dim,dim))
    loA[range(dim),range(dim)] = 1e-4
    lo = np.hstack(([-np.inf]*(dim+s), loA[np.tril_indices(dim)], [-np.inf]*dim))
    P = BoxProjection(lo=lo)

    xlo, xhi = -5, 5
    ylo, yhi = 0, 2
    methods = ['Fcc','Feg','Fcon','Freg','Falt','Funr']
    colors = ['r','b','k','g','gray','orange']
    for method, color in zip(methods,colors):
        Step = -1e-5
        Iters = 10000
        Domain = LQGAN(mu=mu,sig=sig,preconditioner=method)
        Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-5,P=P)
        # Iters = 10000
        # Method = Euler(Domain=Domain,FixStep=True)
        
        # Initialize Starting Point
        Start = np.array([3.,0.,0.2,0.])

        # Set Options
        Init = Initialization(Step=Step)
        Term = Termination(MaxIter=Iters,Tols=[(Domain.dist_Euclidean,1e-4)])
        Repo = Reporting(Requests=['Step', 'F Evaluations',
                                   'Projections','Data',Domain.dist_Euclidean])
        Misc = Miscellaneous()
        Options = DescentOptions(Init,Term,Repo,Misc)

        # Print Stats
        PrintSimStats(Domain,Method,Options)

        # Start Solver
        tic = time.time()
        LQ_Results = Solve(Start,Method,Domain,Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options,LQ_Results,Method,toc)

        data = np.array(LQ_Results.PermStorage['Data'])
        
        X, Y = np.meshgrid(np.linspace(xlo, xhi, 50), np.linspace(ylo, yhi, 50))
        U = np.zeros_like(X)
        V = np.zeros_like(Y)
        for i in range(X.shape[0]):
            for j in range(X.shape[1]):
                vec = -Domain.F(np.array([X[i,j],0.,Y[i,j],0.]))
                U[i,j] = vec[0]
                V[i,j] = vec[2]

        fig = plt.figure()
        ax = fig.add_subplot(111)
        Q = plt.quiver(X[::3, ::3], Y[::3, ::3], U[::3, ::3], V[::3, ::3],
                       pivot='mid', units='inches')
        ax.plot(data[:,0],data[:,2],color=color,label=method)
        ax.plot([data[0,0]],[data[0,2]],'k*')
        ax.plot(mu,sig[0],'c*')
        ax.set_xlim([xlo, xhi])
        ax.set_ylim([0, yhi])
        ax.set_xlabel(r'$w_2$')
        ax.set_ylabel(r'$a$')
        plt.title('Dynamics for '+method)
        plt.savefig(root+method+'_dyn')
示例#20
0
def Demo():

    #__LQ_GAN__##############################################

    # Interpolation between F and RipCurl should probably be nonlinear
    # in terms of L2 norms of matrices if the norms essentially represent the largest eigenvalues

    # what's an example of a pseudomonotone field? stretch vertically linearly a bit? quasimonotone?

    # the extragradient method uses the same step size for the first and second step, as the step size goes
    # to zero, extragradient asymptotes to the projection method
    # modified extragradient methods use different step sizes. if we keep the first step size fixed to some
    # positive value and shrink the second, the dynamics of extragradient remain as desired
    # this is essentially what HE_PhaseSpace is showing
    # HE and HE_PhaseSpace are designed to "simulate" a trajectory - they do not actually change the effective
    # dynamics of the vector field

    # Define Network and Domain
    Domain = LQ(sig=1)

    # Set Method
    lo = [-np.inf, 1e-2]
    # Method = Euler(Domain=Domain,FixStep=True,P=BoxProjection(lo=lo))
    # Method = EG(Domain=Domain,FixStep=True,P=BoxProjection(lo=lo))
    # Method = HeunEuler(Domain=Domain,Delta0=1e-4,P=BoxProjection(lo=lo))
    Method = HeunEuler_PhaseSpace(Domain=Domain,
                                  Delta0=1e-2,
                                  P=BoxProjection(lo=lo))

    # Initialize Starting Point
    # Start = np.random.rand(Domain.Dim)
    scale = 30
    Start = np.array([50., 50.])
    xoff = 0
    yoff = 0
    # no difference between eigenvalues of J at [1.,3.5] and eigenvalues of an outward spiral: a = np.array([[-1,6.92],[-6.92,-1]])
    j = Domain.J(Start)
    print('original evs')
    print(np.linalg.eigvals(j))
    print(np.linalg.eigvals(j + j.T))
    f = Domain.F(Start)
    jsym = j + j.T
    # print(f.dot(jsym.dot(f)))
    tf = Domain.TF(Start)
    print('tf')
    print(tf)
    print(np.linalg.eigvals(tf))
    jrc = Domain.JRipCurl(Start)
    print('jrc')
    print(jrc)
    print(0.5 * (jrc + jrc.T))
    print(np.linalg.eigvals(jrc + jrc.T))
    jreg = Domain.JReg(Start)
    print('jreg')
    print(jreg)
    print(0.5 * (jreg + jreg.T))
    print(np.linalg.eigvals(jreg + jreg.T))
    jasy = j - j.T
    print('exact')
    print(0.5 * np.dot(jasy.T, jasy))

    for gam in np.linspace(0, 1, 20):
        # print(Domain.JRegEV(Start,gam))
        print(Domain.JRCEV(Start, gam))

    jap = approx_jacobian(Domain.F, Start)
    print(jap)
    print(np.linalg.eigvals(0.5 * (jap + jap.T)))

    y = np.array([0, 1])
    x = np.array([1, 1e-1])
    pre = np.dot(Domain.F(y), x - y)
    post = np.dot(Domain.F(x), x - y)
    print(pre)
    print(post)

    d = 2
    W2 = Domain.sym(np.random.rand(d, d))
    w1 = np.random.rand(d)
    A = np.tril(np.random.rand(d, d))
    A[range(d), range(d)] = np.clip(A[range(d), range(d)], 1e-6, np.inf)
    b = np.random.rand(d)
    dmult = np.hstack([W2.flatten(), w1, A.flatten(), b])
    jmult = Domain.Jmult(dmult)
    jskew = (jmult - jmult.T)
    print(np.linalg.matrix_rank(jskew, tol=1e-16))

    W2 = Domain.sym(np.ones((d, d)))
    w1 = np.ones(d)
    A = np.tril(np.ones((d, d)))
    A[range(d), range(d)] = np.clip(A[range(d), range(d)], 0, np.inf)
    b = np.ones(d)
    dmult = np.hstack([W2.flatten(), w1, A.flatten(), b])
    jmult = Domain.Jmult(dmult)
    jskew = (jmult - jmult.T)
    print(np.linalg.matrix_rank(jskew))

    W2 = Domain.sym(np.zeros((d, d)))
    w1 = np.zeros(d)
    A = np.tril(np.ones((d, d)))
    A[range(d), range(d)] = np.clip(A[range(d), range(d)], 0, np.inf)
    b = np.zeros(d)
    dmult = np.hstack([W2.flatten(), w1, A.flatten(), b])
    jmult = Domain.Jmult(dmult)
    jskew = (jmult - jmult.T)
    print(np.linalg.matrix_rank(jskew))

    np.set_printoptions(linewidth=200)

    s = (d**2 + d) // 2
    jskewblock = jskew[:s, s + d:s + d + s]

    embed()

    # Set Options
    Init = Initialization(Step=-1e-5)
    Term = Termination(MaxIter=1000, Tols=[(Domain.dist, 1e-4)])
    Repo = Reporting(
        Requests=['Step', 'F Evaluations', 'Projections', 'Data', Domain.dist])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    LQ_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, LQ_Results, Method, toc)

    data = np.array(LQ_Results.PermStorage['Data'])

    X, Y = np.meshgrid(
        np.arange(-2 * scale + xoff, 2 * scale + xoff, .2 * scale),
        np.arange(1e-2 + yoff, 4 * scale + yoff, .2 * scale))
    U = np.zeros_like(X)
    V = np.zeros_like(Y)
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            vec = -Domain.F([X[i, j], Y[i, j]])
            U[i, j] = vec[0]
            V[i, j] = vec[1]

    fig = plt.figure()
    ax = fig.add_subplot(111)
    Q = plt.quiver(X[::3, ::3],
                   Y[::3, ::3],
                   U[::3, ::3],
                   V[::3, ::3],
                   pivot='mid',
                   units='inches')
    ax.plot(data[:, 0], data[:, 1], '-r')
    ax.plot([data[0, 0]], [data[0, 1]], 'k*')
    ax.plot([data[-1, 0]], [data[-1, 1]], 'b*')
    ax.set_xlim([-2 * scale + xoff, 2 * scale + xoff])
    ax.set_ylim([-.1 * scale + yoff, 4 * scale + yoff])
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    # plt.show()
    # plt.savefig('original.png')
    # plt.savefig('EGoriginal.png')
    # plt.savefig('RipCurl.png')
    # plt.savefig('RipCurl2.png')
    # plt.savefig('EG.png')
    # plt.savefig('GReg.png')
    plt.savefig('Testing.png')
示例#21
0
def Demo():

    #__AFFINE_GAN__##############################################

    # what happens if we force the diagonal of G to lie in R+?
    # G and -G are both equilibrium solutions -- need to rule one out

    # Define Network and Domain
    mean = np.array([1, 2])
    cov = np.array([[1, 0.5], [0.5, 2]])
    lam, phi = np.linalg.eig(cov)
    mat = np.diag(np.sqrt(lam)).dot(phi)
    # Domain = AffineGAN(u=mean,S=cov,batch_size=1000,alpha=0.,expansion=False)

    # Set Method
    # Method = Euler(Domain=Domain,FixStep=True)
    # Method = EG(Domain=Domain,FixStep=True)

    # Initialize Starting Point
    # Start = np.random.rand(Domain.Dim)
    Start = np.zeros(2 * mean.size + cov.size)
    # d0, G0 = Domain.get_args(Start)
    # u0 = G0[:,-1]
    # S0 = G0[:,:Domain.dim]
    # print(u0)
    # print(S0)

    lo = -np.inf * np.ones_like(Start)
    for d in range(mean.size):
        lo[mean.size + d * (mean.size + 1) + d] = 0.

    iter_schedule = [2000, 4000, 4000]
    step_schedule = [1e-1, 1e-2, 1e-2]
    batch_schedule = [100, 100, 10]
    Vs = []

    for it, step, batch_size in zip(iter_schedule, step_schedule,
                                    batch_schedule):

        Domain = AffineGAN(u=mean,
                           S=cov,
                           batch_size=batch_size,
                           alpha=0.,
                           expansion=False)

        # Set Method
        # Method = Euler(Domain=Domain,FixStep=True,P=BoxProjection(lo=lo))
        Method = EG(Domain=Domain, FixStep=True, P=BoxProjection(lo=lo))

        # Set Options
        Init = Initialization(Step=-step)
        Term = Termination(MaxIter=it)
        Repo = Reporting(Requests=[
            Domain.V, 'Step', 'F Evaluations', 'Projections', 'Data'
        ])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        # Print Stats
        PrintSimStats(Domain, Method, Options)

        # Start Solver
        tic = time.time()
        AG_Results = Solve(Start, Method, Domain, Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options, AG_Results, Method, toc)

        Vs += AG_Results.PermStorage[Domain.V]
        Start = AG_Results.TempStorage['Data'][-1]

    # d, G = Domain.get_args(data)
    # u = G[:,-1]
    # S = G[:,:Domain.dim]
    # print(u)
    # print(S)
    print(mat)
    # embed()

    for data in AG_Results.PermStorage['Data'][::400]:

        num_samples = 1000
        real, fake = Domain.generate(data, num_samples)

        # u_est = np.mean(fake,axis=0)
        # S_est = np.dot(fake.T,fake)/num_samples
        # print(u_est)
        # print(S_est)

        fig, axs = plt.subplots(2)
        axs[0].scatter(fake[:, 0],
                       fake[:, 1],
                       s=40,
                       facecolors='none',
                       edgecolors='r',
                       label='fake',
                       zorder=1)
        axs[0].scatter(real[:, 0],
                       real[:, 1],
                       s=40,
                       marker='*',
                       facecolors='none',
                       edgecolors='k',
                       label='real',
                       zorder=0)
        axs[0].set_title('Comparing Distributions')
        axs[0].set_xlim([-5, 10])
        axs[0].set_ylim([-5, 10])
        axs[0].legend()
        axs[1].plot(Vs)
        axs[1].set_xlabel('Iteration')
        axs[1].set_ylabel('Minimax Objective (V)')
        plt.show()
示例#22
0
def Demo():

    #__LQ_GAN__##############################################

    # NEED TO WRITE CODE TO GENERATE N LQ-GANS PER DIMENSION FOR M DIMENSIONS
    # THEN RUN EACH ALGORITHM FROM L STARTING POINTS AND MEASURE RUNTIME AND STEPS
    # UNTIL DESIRED DEGREE OF ACCURACY IS MET, MEASURE ACCURACY WITH EUCLIDEAN DISTANCE TO X^*
    # AND KL DIVERGENCE https://stats.stackexchange.com/questions/60680/kl-divergence-between-two-multivariate-gaussians/60699
    # COMPUTE MIN/MAX/AVG/STD RUNTIME OVER N X L RUNS PER DIMENSION

    # Interpolation between F and RipCurl should probably be nonlinear
    # in terms of L2 norms of matrices if the norms essentially represent the largest eigenvalues

    # what's an example of a pseudomonotone field? stretch vertically linearly a bit? quasimonotone?

    # the extragradient method uses the same step size for the first and second step, as the step size goes
    # to zero, extragradient asymptotes to the projection method
    # modified extragradient methods use different step sizes. if we keep the first step size fixed to some
    # positive value and shrink the second, the dynamics of extragradient remain as desired
    # this is essentially what HE_PhaseSpace is showing
    # HE and HE_PhaseSpace are designed to "simulate" a trajectory - they do not actually change the effective
    # dynamics of the vector field

    # Define Network and Domain
    dim = 1
    s = (dim**2 + dim) // 2
    mu = 10 * np.random.rand(dim)
    mu = np.array([0])
    L = 10 * np.random.rand(dim, dim)
    L[range(dim), range(dim)] = np.clip(L[range(dim), range(dim)], 1e-1,
                                        np.inf)
    L = np.tril(L)
    sig = np.dot(L, L.T)
    sig = np.array([[1]])

    np.set_printoptions(linewidth=200)

    print('mu, sig, sig eigs')
    print(mu)
    print(sig)
    print(np.linalg.eigvals(sig))

    # Set Constraints
    loA = -np.inf * np.ones((dim, dim))
    loA[range(dim), range(dim)] = 1e-2
    lo = np.hstack(
        ([-np.inf] * (dim + s), loA[np.tril_indices(dim)], [-np.inf] * dim))
    P = BoxProjection(lo=lo)

    xoff = 0
    yoff = 0
    scale = 30

    datas = []
    dists = []
    methods = ['ccGD', 'simGD', 'preEG', 'conGD', 'regGD', 'EG']
    # methods = ['simGD']
    # methods = ['ccGD']
    for method in methods:

        if method == 'EG':
            Step = -1e-2
            Iters = 10000
            Domain = LQ(mu=mu, sig=sig, method='simGD')
            Method = EG(Domain=Domain, FixStep=True, P=P)
        elif method == 'simGD':
            Step = -1e-3
            Iters = 100000
            Domain = LQ(mu=mu, sig=sig, method='simGD')
            Method = Euler(Domain=Domain, FixStep=True, P=P)
            # Method = HeunEuler_PhaseSpace(Domain=Domain,Delta0=1e-5,MinStep=-1.,P=P)
        elif method == 'conGD':
            Step = -1e-6
            # Iters = 2750
            Iters = 3000
            Domain = LQ(mu=mu, sig=sig, method=method)
            Method = HeunEuler_PhaseSpace(Domain=Domain, Delta0=1e-5, P=P)
        else:
            Step = -1e-5
            Iters = 10000
            Domain = LQ(mu=mu, sig=sig, method=method)
            Method = HeunEuler_PhaseSpace(Domain=Domain, Delta0=1e-5, P=P)

        # Initialize Starting Point
        Start = np.array([50., 0., 30., 0.])

        # Set Options
        Init = Initialization(Step=Step)
        Term = Termination(MaxIter=Iters, Tols=[(Domain.dist, 1e-4)])
        Repo = Reporting(Requests=[
            'Step', 'F Evaluations', 'Projections', 'Data', Domain.dist
        ])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        # Print Stats
        PrintSimStats(Domain, Method, Options)

        # Start Solver
        tic = time.time()
        LQ_Results = Solve(Start, Method, Domain, Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options, LQ_Results, Method, toc)

        datas += [np.array(LQ_Results.PermStorage['Data'])]
        dists += [np.array(LQ_Results.PermStorage[Domain.dist])]

    X, Y = np.meshgrid(
        np.arange(-2 * scale + xoff, 2 * scale + xoff, .2 * scale),
        np.arange(1e-2 + yoff, 4 * scale + yoff, .2 * scale))
    U = np.zeros_like(X)
    V = np.zeros_like(Y)
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            vec = -Domain.F(np.array([X[i, j], 0., Y[i, j], 0.]))
            U[i, j] = vec[0]
            V[i, j] = vec[2]

    fig = plt.figure()
    ax = fig.add_subplot(111)
    Q = plt.quiver(X[::3, ::3],
                   Y[::3, ::3],
                   U[::3, ::3],
                   V[::3, ::3],
                   pivot='mid',
                   units='inches')
    colors = ['r', 'gray', 'b', 'k', 'g', 'm']
    # colors = ['gray']
    # colors = ['r']
    for data, color, method in zip(datas, colors, methods):
        if method == 'EG':
            ax.plot(data[:, 0], data[:, 2], '--', color=color, label=method)
        else:
            ax.plot(data[:, 0], data[:, 2], color=color, label=method)
    ax.plot([data[0, 0]], [data[0, 2]], 'k*')
    ax.plot(mu, sig[0], 'c*')
    ax.set_xlim([-2 * scale + xoff, 2 * scale + xoff])
    ax.set_ylim([-.1 * scale + yoff, 4 * scale + yoff])
    ax.set_xlabel(r'$w_2$')
    ax.set_ylabel(r'$a$')
    plt.title('Trajectories for Various Equilibrium Algorithms')
    plt.legend()
    # plt.show()
    # plt.savefig('original.png')
    # plt.savefig('EGoriginal.png')
    # plt.savefig('RipCurl.png')
    # plt.savefig('RipCurl2.png')
    # plt.savefig('EG.png')
    # plt.savefig('GReg.png')
    # plt.savefig('Testing.png')
    # plt.savefig('trajcomp_ccGD.png')
    # plt.savefig('trajcomp.png')
    plt.savefig('trajcomp_test.png')
示例#23
0
def Demo():

    # __POWER_ITERATION__##################################################

    # Define Domain
    A = np.asarray([[-4, 10], [7, 5]])
    A = A.dot(A)  # symmetrize
    # mars = np.load('big_means.npy')
    # A = mars.T.dot(mars)
    eigs = np.linalg.eigvals(A)
    rho = max(eigs) - min(eigs)
    rank = np.count_nonzero(eigs)
    # Domain = PowerIteration(A=A)
    Domain = Rayleigh(A=A)

    # Set Method
    Method_Standard = Euler(Domain=Domain,
                            FixStep=True,
                            P=NormBallProjection())

    # Initialize Starting Point
    Start = np.ones(Domain.Dim)

    # Set Options
    Init = Initialization(Step=-1e-3)
    Term = Termination(MaxIter=100, Tols=[(Domain.res_norm, 1e-6)])
    Repo = Reporting(Requests=[
        Domain.res_norm, 'Step', 'F Evaluations', 'Projections', 'Data'
    ])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method_Standard, Options)

    # Start Solver
    tic = time.time()
    Results_Standard = Solve(Start, Method_Standard, Domain, Options)
    toc_standard = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results_Standard, Method_Standard, toc_standard)

    # data_standard = Results_Standard.PermStorage['Data']
    # eigval_standard = (A.dot(data_standard[-1])/data_standard[-1]).mean()
    # eigvec_standard = data_standard[-1]
    res_standard = Results_Standard.PermStorage[Domain.res_norm]

    # Set Method
    # Method_CK = CashKarp(Domain=Domain,Delta0=1e-4,P=NormBallProjection())
    Method_CK = HeunEuler(Domain=Domain, Delta0=1e-4, P=NormBallProjection())

    # Print Stats
    PrintSimStats(Domain, Method_CK, Options)

    # Start Solver
    tic = time.time()
    Results_CK = Solve(Start, Method_CK, Domain, Options)
    toc_CK = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results_CK, Method_CK, toc_CK)

    # data_CK = Results_CK.PermStorage['Data']
    # eigval_CK = (A.dot(data_CK[-1])/data_CK[-1]).mean()
    # eigvec_CK = data_CK[-1]
    res_CK = Results_CK.PermStorage[Domain.res_norm]

    # Set Method
    # Method_CKPS = CashKarp_PhaseSpace(Domain=Domain,Delta0=1e-4,
    #                                   P=NormBallProjection())
    Method_CKPS = HeunEuler_PhaseSpace(Domain=Domain,
                                       Delta0=1e-1,
                                       P=NormBallProjection())

    # Print Stats
    PrintSimStats(Domain, Method_CKPS, Options)

    # Start Solver
    tic = time.time()
    Results_CKPS = Solve(Start, Method_CKPS, Domain, Options)
    toc_CKPS = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results_CK, Method_CK, toc_CKPS)

    # data_CKPS = Results_CKPS.PermStorage['Data']
    # eigval_CKPS = (A.dot(data_CKPS[-1])/data_CKPS[-1]).mean()
    # eigvec_CKPS = data_CKPS[-1]
    res_CKPS = Results_CKPS.PermStorage[Domain.res_norm]

    # tic = time.time()
    # eigval_NP, eigvec_NP = eigh(A,eigvals=(Domain.Dim-1,Domain.Dim-1))
    # toc_NP = time.time() - start

    # Plot Results
    fig = plt.figure()
    ax = fig.add_subplot(2, 1, 1)

    # label = 'Standard Power Iteration with scaling' +\
    #     r' $A \cdot v / ||A \cdot v||$'
    label = 'Standard'
    ax.plot(res_standard, label=label)

    fevals_CK = Results_CK.PermStorage['F Evaluations'][-1]
    # label = Method_CK.__class__.__name__+r' Power Iteration'
    # label += r' $\Delta_0=$'+'{:.0e}'.format(Method_CK.Delta0)
    label = 'CK'
    x = np.linspace(0, fevals_CK, len(res_CK))
    ax.plot(x, res_CK, label=label)

    fevals_CKPS = Results_CKPS.PermStorage['F Evaluations'][-1]
    # label = Method_CKPS.__class__.__name__+' Power Iteration'
    # label += r' $\Delta_0=$'+'{:.0e}'.format(Method_CKPS.Delta0)
    label = 'CKPS'
    x = np.linspace(0, fevals_CKPS, len(res_CKPS))
    ax.plot(x, res_CKPS, '-.', label=label)

    xlabel = r'# of $A \cdot v$ Evaluations'
    ax.set_xlabel(xlabel)

    ylabel = r'Norm of residual ($||\frac{A \cdot v}{||A \cdot v||}$'
    ylabel += r'$ - \frac{v}{||v||}||$)'
    ax.set_ylabel(ylabel)

    sizestr = str(A.shape[0]) + r' $\times$ ' + str(A.shape[1])
    if rho > 100:
        rhostr = r'$\rho(A)=$' + '{:.0e}'.format(rho)
    else:
        rhostr = r'$\rho(A)=$' + str(rho)
    rnkstr = r'$rank(A)=$' + str(rank)
    plt.title(sizestr + ' Matrix with ' + rhostr + ', ' + rnkstr)

    ax.legend()

    xlim = min(max(len(res_standard), fevals_CK, fevals_CKPS), Term.Tols[0])
    xlim = int(np.ceil(xlim / 10.) * 10)
    ax.set_xlim([0, xlim])

    ax.set_yscale('log', nonposy='clip')

    ax2 = fig.add_subplot(2, 1, 2)

    # label = 'Standard Power Iteration with scaling' +\
    #     r' $A \cdot v / ||A \cdot v||$'
    label = 'Standard'
    ax2.plot(res_standard, label=label)

    # label = Method_CK.__class__.__name__+r' Power Iteration'
    # label += r' $\Delta_0=$'+'{:.0e}'.format(Method_CK.Delta0)
    label = 'CK'
    ax2.plot(res_CK, label=label)

    # label = Method_CKPS.__class__.__name__+' Power Iteration'
    # label += r' $\Delta_0=$'+'{:.0e}'.format(Method_CKPS.Delta0)
    label = 'CKPS'
    ax2.plot(res_CKPS, '-.', label=label)

    xlabel = r'# of Iterations'
    ax2.set_xlabel(xlabel)

    ylabel = r'Norm of residual ($||\frac{A \cdot v}{||A \cdot v||}$'
    ylabel += r'$ - \frac{v}{||v||}||$)'
    ax2.set_ylabel(ylabel)

    ax2.legend()

    xlim = min(max(len(res_standard), len(res_CK), len(res_CKPS)),
               Term.Tols[0])
    xlim = int(np.ceil(xlim / 10.) * 10)
    ax2.set_xlim([0, xlim])

    ax2.set_yscale('log', nonposy='clip')

    plt.show()

    embed()
示例#24
0
def Demo():

    #__SERVICE_ORIENTED_INTERNET__##############################################
    N = 2  # number of possible maps
    T = 100  # number of time steps
    eta = .01  # learning rate

    # Define Domains and Compute Equilbria
    Domains = []
    X_Stars = []
    CurlBounds = []
    # for n in range(N):
    n = 0
    while len(X_Stars) < N:
        # Create Domain
        Network = CreateRandomNetwork(m=3,n=2,o=2,seed=n)
        Domain = SOI(Network=Network,alpha=2)

        # Record Domain
        Domains += [Domain]

        # Set Method
        Method = HeunEuler(Domain=Domain,P=BoxProjection(lo=0),Delta0=1e-3)

        # Initialize Starting Point
        Start = np.zeros(Domain.Dim)

        # Calculate Initial Gap
        gap_0 = Domain.gap_rplus(Start)

        # Calculate Curl Bound
        J = approx_jacobian(Domain.F,Start)
        if not np.all(np.linalg.eigvals(J+J.T) >= 0):
            pass
        _J = approx_jacobian(Domain.F,Start+0.5)
        assert np.allclose(J,_J,atol=1e-5)
        CurlBounds += [np.sqrt(18)*svds(J,k=1,which='LM',return_singular_vectors=False).item()]

        # Set Options
        Init = Initialization(Step=-1e-10)
        Term = Termination(MaxIter=25000,Tols=[(Domain.gap_rplus,1e-6*gap_0)])
        Repo = Reporting(Requests=[Domain.gap_rplus])
        Misc = Miscellaneous()
        Options = DescentOptions(Init,Term,Repo,Misc)

        # Print Stats
        PrintSimStats(Domain,Method,Options)

        # Start Solver
        tic = time.time()
        SOI_Results = Solve(Start,Method,Domain,Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options,SOI_Results,Method,toc)

        # Record X_Star
        X_Star = SOI_Results.TempStorage['Data'][-1]
        X_Stars += [X_Star]
        n += 1
    X_Stars = np.asarray(X_Stars)

    # Compute Equilibrium of Average Domain
    Domain = AverageDomains(Domains)

    # Set Method
    Method = HeunEuler_PhaseSpace(Domain=Domain,P=BoxProjection(lo=0),Delta0=1e-3)

    # Initialize Starting Point
    Start = np.zeros(Domain.Dim)

    J = approx_jacobian(Domain.F,Start)
    assert np.all(np.linalg.eigvals(J+J.T) >= 0)

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-10)
    Term = Termination(MaxIter=25000,Tols=[(Domain.gap_rplus,1e-10*gap_0)])
    Repo = Reporting(Requests=[Domain.gap_rplus])
    Misc = Miscellaneous()
    Options = DescentOptions(Init,Term,Repo,Misc)

    # Print Stats
    PrintSimStats(Domain,Method,Options)

    # Start Solver
    tic = time.time()
    SOI_Results = Solve(Start,Method,Domain,Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options,SOI_Results,Method,toc)

    # Record X_Opt
    X_Opt = SOI_Results.TempStorage['Data'][-1]
    # X_Opt = X_Stars[0]

    print('Starting Online Learning')

    # Set First Prediction
    X = np.zeros(X_Stars.shape[1])

    # Select First Domain
    idx = np.argmax(np.linalg.norm(X_Stars - X,axis=1))

    distances = []
    loss_infs = []
    regret_standards = []
    regret_news = []
    stokes = []
    ts = range(T)
    for t in ts:
        print('t = '+str(t))
        # retrieve domain
        Domain = Domains[idx]
        # retrieve equilibrium / reference vector
        # equi = X_Stars[idx]
        equi = np.zeros_like(X_Stars[idx])
        # calculate distance
        distances += [np.linalg.norm(X_Opt-X)]
        # calculate infinity loss
        # loss_infs += [infinity_loss(Domain,X)]
        # calculate standard regret
        ci_predict = ContourIntegral(Domain,LineContour(equi,X))
        predict_loss = integral(ci_predict)
        ci_opt = ContourIntegral(Domain,LineContour(equi,X_Opt))
        predict_opt = integral(ci_opt)
        regret_standards += [predict_loss - predict_opt]
        # calculate new regret
        ci_new = ContourIntegral(Domain,LineContour(X_Opt,X))
        regret_news += [integral(ci_new)]
        # calculate bound
        # area = 0.5*np.prod(np.sort([np.linalg.norm(X_Opt-equi),np.linalg.norm(X-X_Opt),np.linalg.norm(equi-X)])[:2])  # area upper bound
        area = herons(X_Opt,X,equi)  # exact area
        stokes += [CurlBounds[idx]*area]
        # update prediction
        X = BoxProjection(lo=0).P(X,-eta,Domain.F(X))
        # update domain
        idx = np.argmax(np.linalg.norm(X_Stars - X,axis=1))
    # embed()
    ts_p1 = range(1,T+1)
    distances_avg = np.divide(np.cumsum(distances),ts_p1)
    # loss_infs_avg = np.divide(np.cumsum(loss_infs),ts_p1)
    regret_standards_avg = np.divide(np.cumsum(regret_standards),ts_p1)
    regret_news_avg = np.divide(np.cumsum(regret_news),ts_p1)
    stokes = np.divide(np.cumsum(stokes),ts_p1)

    # np.savez_compressed('NoRegret_MLN.npz',d_avg=distances_avg,
    #                     linf_avg=loss_infs_avg,rs_avg=regret_standards_avg,
    #                     rn_avg=regret_news_avg,stokes=stokes)

    plt.subplot(2, 1, 2)
    plt.plot(ts, distances_avg, 'k',label='Average Distance')
    plt.title('Demonstration of No-Regret on MLN')
    plt.ylabel('Euclidean Distance')
    plt.legend()

    plt.subplot(2, 1, 1)
    # plt.plot(ts, loss_infs_avg, 'k--', label=r'loss$_{\infty}$')
    plt.plot(ts, regret_standards_avg, 'r--o', markevery=T//20,
             label=r'regret$_{s}$')
    plt.plot(ts, regret_news_avg, 'b-', label=r'regret$_{n}$')
    # plt.fill_between(ts, regret_news_avg-stokes, regret_news_avg+stokes,
    #                  facecolor='c', alpha=0.2, zorder=0, label='Stokes Bound')
    plt.plot(ts, np.zeros_like(ts), 'w-', lw=1)
    plt.xlabel('Time Step')
    plt.ylabel('Aggregate System-Wide Loss')
    plt.xlim([0,T])
    # plt.ylim([-250,1000])
    plt.legend()
    plt.title('Demonstration of No-Regret on MLN')

    plt.savefig('NoRegret_MLN2')

    # data = np.load('NoRegret2.npz')
    # distances_avg = data['d_avg']
    # loss_infs_avg = data['linf_avg']
    # regret_standards_avg = data['rs_avg']
    # regret_news_avg = data['rn_avg']
    # stokes = data['stokes']
    # ts = range(len(distances_avg))

    embed()
示例#25
0
def Demo():

    # __PENN_TREE_BANK____#################################################

    # Load Data
    # seq = np.arange(1000)
    train, valid, test, id_to_word, vocab = ptb_raw_data(
        '/Users/imgemp/Desktop/Data/simple-examples/data/')
    words, given_embeddings = pickle.load(open(
        '/Users/imgemp/Desktop/Data/polyglot-en.pkl', 'rb'),
                                          encoding='latin1')
    words_low = [word.lower() for word in words]
    word_to_id = dict(zip(words_low, range(len(words))))
    word_to_id['<eos>'] = word_to_id['</s>']
    y0 = get_y0(train, vocab)

    EDim = 5
    fix_embedding = False
    learn_embedding = True
    if fix_embedding:
        EDim = given_embeddings.shape[1]
        learn_embedding = False

    # Define Domain
    Domain = PennTreeBank(seq=train,
                          y0=None,
                          EDim=EDim,
                          batch_size=100,
                          learn_embedding=learn_embedding,
                          ord=1)

    # Set Method
    P = PTBProj(Domain.EDim)
    # Method = Euler(Domain=Domain,FixStep=True,P=P)
    Method = HeunEuler(Domain=Domain,
                       P=P,
                       Delta0=1e-4,
                       MinStep=-3.,
                       MaxStep=0.)
    # Method = CashKarp(Domain=Domain,P=P,Delta0=1e-1,MinStep=-5.,MaxStep=0.)

    # Set Options
    Term = Termination(MaxIter=10000)
    Repo = Reporting(
        Interval=10,
        Requests=[Domain.Error, Domain.PercCorrect, Domain.Perplexity,
                  'Step'])  #,
    # 'Step', 'F Evaluations',
    # 'Projections','Data'])
    Misc = Miscellaneous()
    Init = Initialization(Step=-1e-3)
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Initialize Starting Point
    if fix_embedding:
        missed = 0
        params = np.random.rand(Domain.param_len)
        avg_norm = np.linalg.norm(given_embeddings, axis=1).mean()
        embeddings = []
        for i in range(vocab):
            word = id_to_word[i]
            if word in word_to_id:
                embedding = given_embeddings[word_to_id[word]]
            else:
                missed += 1
                embedding = np.random.rand(Domain.EDim)
                embedding *= avg_norm / np.linalg.norm(embedding)
            embeddings += [embedding]
        polyglot_embeddings = np.hstack(embeddings)
        Start = np.hstack((params, polyglot_embeddings))
        print(np.linalg.norm(polyglot_embeddings))
        print(
            'Missing %d matches in polyglot dictionary -> given random embeddings.'
            % missed)
    else:
        # params = np.random.rand(Domain.param_len)*10
        # embeddings = np.random.rand(EDim*vocab)*.1
        # Start = np.hstack((params,embeddings))
        # assert Start.shape[0] == Domain.Dim
        Start = np.random.rand(Domain.Dim)
    Start = P.P(Start)

    # Compute Initial Error
    print('Initial training error: %g' % Domain.Error(Start))
    print('Initial perplexity: %g' % Domain.Perplexity(Start))
    print('Initial percent correct: %g' % Domain.PercCorrect(Start))

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    PTB_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, PTB_Results, Method, toc)

    # Plot Results
    err = np.asarray(PTB_Results.PermStorage[Domain.Error])
    pc = np.asarray(PTB_Results.PermStorage[Domain.PercCorrect])
    perp = np.asarray(PTB_Results.PermStorage[Domain.Perplexity])
    steps = np.asarray(PTB_Results.PermStorage['Step'])
    t = np.arange(0, len(steps) * Repo.Interval, Repo.Interval)
    fig = plt.figure()
    ax = fig.add_subplot(411)
    ax.semilogy(t, err)
    ax.set_ylabel('Training Error')
    ax.set_title('Penn Tree Bank Training Evaluation')
    ax = fig.add_subplot(412)
    ax.semilogy(t, perp)
    ax.set_ylabel('Perplexity')
    ax = fig.add_subplot(413)
    ax.plot(t, pc)
    ax.set_ylabel('Percent Correct')
    ax = fig.add_subplot(414)
    ax.plot(t, steps)
    ax.set_ylabel('Step Size')
    ax.set_xlabel('Iterations (k)')
    plt.savefig('PTB')

    params_embeddings = np.asarray(PTB_Results.TempStorage['Data']).squeeze()
    params, embeddings = np.split(params_embeddings, [Domain.param_len])
    embeddings_split = np.split(embeddings, vocab)

    dists_comp = pdist(np.asarray(embeddings_split))
    dists_min = np.min(dists_comp)
    dists_max = np.max(dists_comp)
    dists = squareform(dists_comp)
    dists2 = np.asarray([np.linalg.norm(e) for e in embeddings_split])
    print('pairwise dists', np.mean(dists), dists_min, dists_max)
    print('embedding norms', np.mean(dists2), np.min(dists2), np.max(dists2))
    print('params', np.mean(params), np.min(np.abs(params)),
          np.max(np.abs(params)))
示例#26
0
def Demo():

    #__SERVICE_ORIENTED_INTERNET__##############################################
    N = 10  # number of possible maps
    T = 1000  # number of time steps
    eta = 1e-3  # learning rate

    print('Creating Domains')

    # Define Domains and Compute Equilbria
    Domains = []
    X_Stars = []
    CurlBounds = []
    n = 0
    while len(Domains) < N:
        # Create Domain
        Network = CreateRandomNetwork(m=3, n=2, o=2, seed=None)
        Domain = SOI(Network=Network, alpha=2)

        # Initialize Starting Point
        Start = np.zeros(Domain.Dim)

        # Assert PD
        J = approx_jacobian(Domain.F, Start)
        eigs = np.linalg.eigvals(J + J.T)
        if not np.all(eigs > 0):
            continue
        _J = approx_jacobian(Domain.F, Start + 0.5)
        assert np.allclose(J, _J,
                           atol=1e-5)  # assert J is constant (unique for SOI)

        # Record Domain
        Domains += [Domain]

        # Calculate Initial Gap
        gap_0 = Domain.gap_rplus(Start)

        # Calculate Curl Bound
        CurlBounds += [
            np.sqrt(8) *
            svds(J, k=1, which='LM', return_singular_vectors=False).item()
        ]

        # Set Method
        Method = HeunEuler(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-3)

        # Set Options
        Init = Initialization(Step=-1e-10)
        Term = Termination(MaxIter=25000,
                           Tols=[(Domain.gap_rplus, 1e-6 * gap_0)])
        Repo = Reporting(Requests=[Domain.gap_rplus])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        # Print Stats
        PrintSimStats(Domain, Method, Options)

        # Start Solver
        tic = time.time()
        SOI_Results = Solve(Start, Method, Domain, Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options, SOI_Results, Method, toc)

        # Record X_Star
        X_Star = SOI_Results.TempStorage['Data'][-1]
        X_Stars += [X_Star]
        n += 1
    X_Stars = np.asarray(X_Stars)

    print('Starting Online Learning')

    # Set First Prediction
    X = np.zeros(X_Stars.shape[1])

    # Select First Domain
    idx = np.random.choice(len(Domains))

    # Domain Sequence
    idx_seq = []
    X_seq = []
    F_seq = []

    ts = range(T)
    for t in ts:
        print('t = ' + str(t), end='\r')
        # record prediction
        X_seq += [X]
        # record domain
        idx_seq += [idx]
        # retrieve domain
        Domain = Domains[idx]
        # record F
        FX = Domain.F(X)
        F_seq += [FX]
        # update prediction
        X = BoxProjection(lo=0).P(X, -eta, FX)
        # update domain
        idx = np.random.choice(len(Domains))

    print('Computing Optimal Strategy')

    weights = np.bincount(idx_seq, minlength=len(Domains)) / len(idx_seq)
    print('Weights: ', weights)

    # Compute Equilibrium of Average Domain
    Domain = AverageDomains(Domains, weights=weights)

    # Set Method
    Method = HeunEuler_PhaseSpace(Domain=Domain,
                                  P=BoxProjection(lo=0),
                                  Delta0=1e-5)

    # Initialize Starting Point
    Start = np.zeros(Domain.Dim)

    # Assert PSD - sum of PSD is PSD doesn't hurt to check
    J = approx_jacobian(Domain.F, Start)
    eigs = np.linalg.eigvals(J + J.T)
    assert np.all(eigs > 0)
    sigma = min(eigs)

    # Calculate Initial Gap
    gap_0 = Domain.gap_rplus(Start)

    # Set Options
    Init = Initialization(Step=-1e-10)
    Term = Termination(MaxIter=25000, Tols=[(Domain.gap_rplus, 1e-10 * gap_0)])
    Repo = Reporting(Requests=[Domain.gap_rplus])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    SOI_Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, SOI_Results, Method, toc)

    print('Computing Regrets')

    # Record X_Opt
    X_Opt = SOI_Results.TempStorage['Data'][-1]

    # Record constants for bounds
    L = np.sqrt(np.mean(np.linalg.norm(F_seq, axis=1)**2.))
    # B = np.linalg.norm(X_Opt)
    B = 2. * np.max(np.linalg.norm(X_Stars, axis=1))
    eta_opt = B / (L * np.sqrt(2 * T))
    bound_opt = B * L * np.sqrt(2 * T)
    reg_bound = (B**2) / (2 * eta) + eta * T * L**2

    opt_distances = []
    equi_distances = []
    regret_standards = []
    regret_news = []
    Fnorms = []
    stokes_exact = []
    stokes = []
    areas_exact = []
    areas = []
    ts = range(T)
    for t in ts:
        print('t = ' + str(t), end='\r')
        idx = idx_seq[t]
        X = X_seq[t]
        # retrieve domain
        Domain = Domains[idx]
        # retrieve equilibrium / reference vector
        if t > 0:
            equi = X_seq[t - 1]
        else:
            # equi = np.zeros_like(X)
            equi = X
        # calculate distance
        opt_distances += [np.linalg.norm(X_Opt - X)]
        equi_distances += [np.linalg.norm(equi - X)]
        # calculate standard regret
        ci_predict = ContourIntegral(Domain, LineContour(equi, X))
        predict_loss = integral(ci_predict)
        ci_opt = ContourIntegral(Domain, LineContour(equi, X_Opt))
        predict_opt = integral(ci_opt)
        regret_standards += [predict_loss - predict_opt]
        # calculate new regret
        ci_new = ContourIntegral(Domain, LineContour(X_Opt, X))
        regret_news += [integral(ci_new)]
        # calculate bound
        area_exact = herons(X_Opt, X, equi)  # exact area
        area = eta_opt * L * (np.linalg.norm(X) + B)
        areas_exact += [area_exact]
        areas += [area]
        stokes_exact += [CurlBounds[idx] * area_exact]
        stokes += [CurlBounds[idx] * area]
        # stokes += [np.max(CurlBounds[idx]*regret_news[-1]/sigma,0)]
        # calculate Fnorm
        Fnorms += [np.linalg.norm(F_seq[t])]

    ts_p1 = range(1, T + 1)
    opt_distances_avg = np.divide(np.cumsum(opt_distances), ts_p1)
    equi_distances_avg = np.divide(np.cumsum(equi_distances), ts_p1)
    regret_standards_avg = np.divide(np.cumsum(regret_standards), ts_p1)
    regret_news_avg = np.divide(np.cumsum(regret_news), ts_p1)
    areas_exact_avg = np.divide(np.cumsum(areas_exact), ts_p1)
    areas_avg = np.divide(np.cumsum(areas), ts_p1)
    stokes_exact_avg = np.divide(np.cumsum(stokes_exact), ts_p1)
    stokes_avg = np.divide(np.cumsum(stokes), ts_p1)
    Fnorms_avg = np.divide(np.cumsum(Fnorms), ts_p1)

    np.savez_compressed('NoRegret_MLN_new.npz',
                        opt_d_avg=opt_distances_avg,
                        equi_d_avg=equi_distances_avg,
                        rs_avg=regret_standards_avg,
                        rn_avg=regret_news_avg,
                        stokes_exact=stokes_exact_avg,
                        stokes=stokes_avg)

    plt.subplot(2, 1, 2)
    plt.semilogy(ts,
                 opt_distances_avg,
                 'k',
                 label='Average Distance to Optimal')
    plt.semilogy(ts,
                 equi_distances_avg,
                 'r',
                 label='Average Distance to Reference')
    plt.semilogy(ts, areas_exact_avg, 'g-', label='Area (exact)')
    plt.semilogy(ts, areas_avg, 'm-', label='Area')
    plt.semilogy(ts, Fnorms_avg, 'b-', label='Fnorms')
    # plt.title('Demonstration of No-Regret on MLN')
    plt.xlabel('Time Step')
    plt.ylabel('Euclidean Distance')
    # plt.legend()
    lgd1 = plt.legend(bbox_to_anchor=(1.05, 1), loc=2)

    plt.subplot(2, 1, 1)
    plt.plot(ts,
             regret_standards_avg,
             'r--o',
             markevery=T // 20,
             label=r'regret$_{s}$')
    plt.plot(ts, regret_news_avg, 'b-', label=r'regret$_{n}$')
    plt.fill_between(ts,
                     regret_news_avg - stokes,
                     regret_news_avg + stokes,
                     facecolor='c',
                     alpha=0.2,
                     zorder=5,
                     label='Stokes Bound')
    plt.fill_between(ts,
                     regret_news_avg - stokes_exact,
                     regret_news_avg + stokes_exact,
                     facecolor='c',
                     alpha=0.2,
                     zorder=5,
                     label='Stokes Bound (exact)')

    # plt.plot(ts, np.zeros_like(ts), 'w-', lw=1)
    # plt.xlabel('Time Step')
    plt.ylabel('Aggregate System-Wide Loss')
    plt.xlim([0, T])
    plt.ylim([-5000, 5000])
    # plt.legend(loc='lower right')
    lgd2 = plt.legend(bbox_to_anchor=(1.05, 1), loc=2)
    plt.title('Demonstration of No-Regret on MLN')

    plt.savefig('NoRegret_MLN_new.pdf',
                format='pdf',
                additional_artists=[lgd1, lgd2],
                bbox_inches='tight')

    fontsize = 18
    plt.figure()
    plt.subplot(1, 1, 1)
    plt.plot(ts,
             regret_standards_avg,
             'r--o',
             markevery=T // 20,
             label=r'regret$_{s}$')
    plt.plot(ts, regret_news_avg, 'b-', label=r'regret$_{n}$')
    # plt.fill_between(ts, regret_news_avg-stokes, regret_news_avg+stokes,
    #                  facecolor='c', alpha=0.2, zorder=5, label='Stokes Bound')
    plt.fill_between(ts,
                     regret_news_avg - stokes_exact,
                     regret_news_avg + stokes_exact,
                     facecolor='c',
                     alpha=0.2,
                     zorder=5,
                     label='Stokes Bound')

    plt.plot(ts, np.zeros_like(ts), 'w-', lw=1)
    plt.xlabel('Time Step', fontsize=fontsize)
    plt.ylabel('Negative Auto-Welfare', fontsize=fontsize)
    plt.xlim([0, T])
    plt.ylim([0, 5000])
    # plt.legend(loc='lower right')
    lgd = plt.legend(bbox_to_anchor=(1.05, 1), loc=2, fontsize=fontsize)
    plt.title('Demonstration of No-Regret on MLN', fontsize=fontsize)

    plt.savefig('NoRegret_MLN_new2.pdf',
                format='pdf',
                additional_artists=[lgd],
                bbox_inches='tight')

    plt.figure()
    plt.subplot(1, 1, 1)
    plt.plot(ts,
             -regret_standards_avg,
             'r--o',
             markevery=T // 20,
             label=r'regret$_{2}$')
    plt.plot(ts, -regret_news_avg, 'b-', label=r'regret$_{1}$')
    # plt.fill_between(ts, regret_news_avg-stokes, regret_news_avg+stokes,
    #                  facecolor='c', alpha=0.2, zorder=5, label='Stokes Bound')
    plt.fill_between(ts,
                     -regret_news_avg - stokes_exact,
                     -regret_news_avg + stokes_exact,
                     facecolor='c',
                     alpha=0.2,
                     zorder=5,
                     label='Stokes Bound')

    plt.plot(ts, np.zeros_like(ts), 'w-', lw=1)
    plt.xlabel('Time Step', fontsize=fontsize)
    plt.ylabel('Auto-Welfare Regret', fontsize=fontsize)
    plt.xlim([0, T])
    plt.ylim([-5000, 0])
    # plt.legend(loc='lower right')
    lgd = plt.legend(bbox_to_anchor=(1.05, 1), loc=2, fontsize=fontsize)
    plt.title('Demonstration of No-Regret on MLN', fontsize=fontsize)

    plt.savefig('NoRegret_MLN_new3.pdf',
                format='pdf',
                additional_artists=[lgd],
                bbox_inches='tight')

    plt.figure()
    plt.subplot(1, 1, 1)
    plt.plot(ts, regret_news_avg, 'b-')
    # plt.fill_between(ts, regret_news_avg-stokes, regret_news_avg+stokes,
    #                  facecolor='c', alpha=0.2, zorder=5, label='Stokes Bound')
    # plt.fill_between(ts, -regret_news_avg-stokes_exact, -regret_news_avg+stokes_exact,
    #                  facecolor='c', alpha=0.2, zorder=5, label='Stokes Bound')

    plt.plot(ts, np.zeros_like(ts), 'w-', lw=1)
    plt.xlabel('Time Step', fontsize=fontsize)
    plt.ylabel('OMO Path Integral Regret', fontsize=fontsize)
    plt.xlim([0, T])
    plt.ylim([0, 5000])
    # plt.legend(loc='lower right')
    # lgd = plt.legend(bbox_to_anchor=(1.05, 1), loc=2, fontsize=fontsize)
    plt.title('Demonstration of No-Regret on MLN', fontsize=fontsize)

    plt.savefig('NoRegret_MLN_new4.pdf', format='pdf', bbox_inches='tight')

    sat_exact = np.logical_or(
        regret_standards_avg >= regret_news_avg - stokes_exact,
        regret_standards_avg <= regret_news_avg + stokes_exact)
    sat = np.logical_or(regret_standards_avg >= regret_news_avg - stokes,
                        regret_standards_avg <= regret_news_avg + stokes)

    embed()
示例#27
0
def Demo():

    #__SERVICE_ORIENTED_INTERNET__##############################################
    N = 10  # number of possible maps
    T = 1000  # number of time steps
    eta = .01  # learning rate
    Ot = 0  # reference vector will be origin for all maps

    # Define Domains and Compute Equilbria
    Domains = []
    X_Stars = []
    for n in range(N):
        # Create Domain
        Network = CreateRandomNetwork(m=3, n=2, o=2, seed=n)
        Domain = SOI(Network=Network, alpha=2)

        # Record Domain
        Domains += [Domain]

        # Set Method
        Method = HeunEuler(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-3)

        # Initialize Starting Point
        Start = np.zeros(Domain.Dim)

        # Calculate Initial Gap
        gap_0 = Domain.gap_rplus(Start)

        # Set Options
        Init = Initialization(Step=-1e-10)
        Term = Termination(MaxIter=25000,
                           Tols=[(Domain.gap_rplus, 1e-6 * gap_0)])
        Repo = Reporting(Requests=[Domain.gap_rplus])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        # Print Stats
        PrintSimStats(Domain, Method, Options)

        # Start Solver
        tic = time.time()
        SOI_Results = Solve(Start, Method, Domain, Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options, SOI_Results, Method, toc)

        # Record X_Star
        X_Star = SOI_Results.TempStorage['Data'][-1]
        X_Stars += [X_Star]
    X_Stars = np.asarray(X_Stars)
    X_Opt = np.mean(X_Stars, axis=0)
    Ot = Ot * np.ones(X_Stars.shape[1])

    print('Starting Online Learning')

    # Set First Prediction
    X = np.zeros(X_Stars.shape[1])

    # Select First Domain
    idx = np.argmax(np.linalg.norm(X_Stars - X, axis=1))

    distances = []
    loss_infs = []
    regret_standards = []
    regret_news = []
    ts = range(T)
    for t in ts:
        print('t = ' + str(t))
        # retrieve domain
        Domain = Domains[idx]
        # retrieve equilibrium
        equi = X_Stars[idx]
        # calculate distance
        distances += [np.linalg.norm(equi - X)]
        # calculate infinity loss
        loss_infs += [infinity_loss(Domain, X)]
        # calculate standard regret
        ci_predict = ContourIntegral(Domain, LineContour(Ot, X))
        predict_loss = integral(ci_predict)
        ci_opt = ContourIntegral(Domain, LineContour(Ot, X_Opt))
        predict_opt = integral(ci_opt)
        regret_standards += [predict_loss - predict_opt]
        # calculate new regret
        ci_new = ContourIntegral(Domain, LineContour(X_Opt, X))
        regret_news += [integral(ci_new)]
        # update prediction
        X = BoxProjection(lo=0).P(X, -eta, Domain.F(X))
        # update domain
        idx = np.argmax(np.linalg.norm(X_Stars - X, axis=1))
    ts_p1 = range(1, T + 1)
    distances_avg = np.divide(distances, ts_p1)
    loss_infs_avg = np.divide(loss_infs, ts_p1)
    regret_standards_avg = np.divide(regret_standards, ts_p1)
    regret_news_avg = np.divide(regret_news, ts_p1)

    np.savez_compressed('NoRegret.npz',
                        d_avg=distances_avg,
                        linf_avg=loss_infs_avg,
                        rs_avg=regret_standards_avg,
                        rn_avg=regret_news_avg)

    plt.subplot(2, 1, 1)
    plt.plot(ts, distances_avg, 'k', label='Average Distance')
    plt.title('Demonstration of No-Regret on MLN')
    plt.ylabel('Euclidean Distance')
    plt.legend()

    plt.subplot(2, 1, 2)
    plt.plot(ts, loss_infs_avg, 'k--', label=r'loss$_{\infty}$')
    plt.plot(ts,
             regret_standards_avg,
             'r--o',
             markevery=T // 20,
             label=r'regret$_{s}$')
    plt.plot(ts, regret_news_avg, 'b-', label=r'regret$_{n}$')
    plt.xlabel('Time Step')
    plt.ylabel('Aggregate System-Wide Loss')
    plt.xlim([0, T])
    plt.ylim([-500, 5000])
    plt.legend()

    plt.savefig('NoRegret')
示例#28
0
def Demo():

    # __KACZMARZ__###############################################################

    # Define Domain
    Domain = NewDomain(F=lambda x: 0, Dim=5)

    # Define Hyperplanes
    dim = max(Domain.Dim - 1, 1)
    N = 3
    hyps = [np.random.rand(Domain.Dim, dim) for n in xrange(N)]

    # Set Method
    P_random = HyperplaneProjection(hyperplanes=hyps, sequence='random')
    Method = Euler(Domain=Domain, FixStep=True, P=P_random)

    # Initialize Starting Point
    Start = np.ones(Domain.Dim)

    # Set Options
    Init = Initialization(Step=0.)
    Term = Termination(MaxIter=50)
    Repo = Reporting(Requests=['Step', 'Data'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init, Term, Repo, Misc)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    data_random = Results.PermStorage['Data']

    # Set Method
    P_cyclic = HyperplaneProjection(hyperplanes=hyps, sequence='cyclic')
    Method = Euler(Domain=Domain, FixStep=True, P=P_cyclic)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    data_cyclic = Results.PermStorage['Data']

    # Set Method
    P_distal = HyperplaneProjection(hyperplanes=hyps, sequence='distal')
    Method = Euler(Domain=Domain, FixStep=True, P=P_distal)

    # Print Stats
    PrintSimStats(Domain, Method, Options)

    # Start Solver
    tic = time.time()
    Results = Solve(Start, Method, Domain, Options)
    toc = time.time() - tic

    # Print Results
    PrintSimResults(Options, Results, Method, toc)

    data_distal = Results.PermStorage['Data']

    # diff_norm_random = np.linalg.norm(np.diff(data_random),axis=1)
    # diff_norm_cyclic = np.linalg.norm(np.diff(data_cyclic),axis=1)
    # diff_norm_distal = np.linalg.norm(np.diff(data_distal),axis=1)\
    # plt.plot(diff_norm_random,label='random')
    # plt.plot(diff_norm_cyclic,label='cyclic')
    # plt.plot(diff_norm_distal,label='distal')
    er = [
        np.linalg.norm(P_random.errors(d), axis=1).max() for d in data_random
    ]
    ec = [
        np.linalg.norm(P_cyclic.errors(d), axis=1).max() for d in data_cyclic
    ]
    ed = [
        np.linalg.norm(P_distal.errors(d), axis=1).max() for d in data_distal
    ]
    plt.plot(er, label='random')
    plt.plot(ec, label='cyclic')
    plt.plot(ed, label='distal')
    plt.legend()
    plt.title('Kaczmarz Algorithm')
    plt.xlabel('Iterations')
    plt.ylabel('Maximum distance from any hyperplane')
    plt.show()
def plotFigure6(saveFig=False):
    print('CloudServices BoA')

    msg = 'This method will run for about a week.\n' +\
        'Email [email protected] for the results .npy file directly.\n' +\
        'Continue? (y/n) '
    cont = input(msg)
    if cont != 'y':
        return

    # Define Network and Domain
    Network = CreateNetworkExample(ex=2)
    Domain = CloudServices(Network=Network,gap_alpha=2)

    # Set Method
    eps = 1e-2
    Method = HeunEuler_LEGS(Domain=Domain,P=BoxProjection(lo=eps),Delta0=1e0)

    # Set Options
    Init = Initialization(Step=-1e-3)
    Term = Termination(MaxIter=1e5)
    Repo = Reporting(Requests=['Data','Step'])
    Misc = Miscellaneous()
    Options = DescentOptions(Init,Term,Repo,Misc)
    args = (Method,Domain,Options)
    sim = Solve

    # Print Stats
    PrintSimStats(Domain,Method,Options)

    # Construct grid
    grid = [np.array([.5,3.5,6])]*Domain.Dim
    grid = ListONP2NP(grid)
    grid = aug_grid(grid)
    Dinv = np.diag(1./grid[:,3])

    # Compute results
    results = MCT(sim,args,grid,nodes=16,limit=40,AVG=0.00,
                  eta_1=1.2,eta_2=.95,eps=1.,
                  L=16,q=8,r=1.1,Dinv=Dinv)
    ref, data, p, iters, avg, bndry_ids, starts = results

    # Save results
    sim_data = [results,Domain,grid]
    np.save('cloud_'+time.strftime("%Y%m%d_%H%M%S"),sim_data)

    # Plot BoAs
    obs = (4,9)  # Look at new green-tech company
    consts = np.array([3.45,2.42,3.21,2.27,np.inf,.76,.97,.75,1.03,np.inf])
    txt_locs = [(1.6008064516129032, 1.6015625),
                (3.2, 3.2),
                (3.33, 2.53)]
    xlabel = '$p_'+repr(obs[0])+'$'
    ylabel = '$q_'+repr(obs[1])+'$'
    title = 'Boundaries of Attraction for Cloud Services Market'
    fig, ax = plotBoA(ref,data,grid,obs=obs,consts=consts,txt_locs=txt_locs,
                      xlabel=xlabel,ylabel=ylabel,title=title)

    if saveFig:
        plt.savefig('BoA.png',bbox_inches='tight')
    return fig, ax
示例#30
0
def Demo():

    #__ONLINE_MONOTONE_EQUILIBRATION_DEMO_OF_A_SERVICE_ORIENTED_INTERNET__######

    # Define Number of Different VIs
    N = 10
    np.random.seed(0)

    # Define Initial Network and Domain
    World = np.random.randint(N)
    Worlds = [World]
    Network = CreateRandomNetwork(m=3, n=2, o=2, seed=World)
    Domain = SOI(Network=Network, alpha=2)

    # Define Initial Strategy
    Strategies = [np.zeros(Domain.Dim)]
    eta = 0.1

    for t in range(1000):

        #__PERFORM_SINGLE_UPDATE

        print('Time ' + str(t))

        # Set Method
        Method = Euler(Domain=Domain, P=BoxProjection(lo=0))

        # Set Options
        Init = Initialization(Step=-eta)
        Term = Termination(MaxIter=1)
        Repo = Reporting(Requests=['Data'])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        # Run Update
        Result = Solve(Strategies[-1], Method, Domain, Options)

        # Get New Strategy
        Strategy = Result.PermStorage['Data'][-1]
        Strategies += [Strategy]

        #__DEFINE_NEXT_VI

        # Define Initial Network and Domain
        World = np.random.randint(N)
        Worlds += [World]
        Network = CreateRandomNetwork(m=3, n=2, o=2, seed=World)
        Domain = SOI(Network=Network, alpha=2)

    # Scrap Last Strategy / World
    Strategies = np.asarray(Strategies[:-1])
    Worlds = Worlds[:-1]

    # Store Equilibrium Strategies
    Equilibria = dict()

    for w in np.unique(Worlds):

        print('World ' + str(w))

        #__FIND_EQUILIBRIUM_SOLUTION_OF_VI

        # Define Initial Network and Domain
        Network = CreateRandomNetwork(m=3, n=2, o=2, seed=w)
        Domain = SOI(Network=Network, alpha=2)

        # Set Method
        Method = HeunEuler(Domain=Domain, P=BoxProjection(lo=0), Delta0=1e-5)

        # Initialize Starting Point
        Start = np.zeros(Domain.Dim)

        # Calculate Initial Gap
        gap_0 = Domain.gap_rplus(Start)

        # Set Options
        Init = Initialization(Step=-1e-10)
        Term = Termination(MaxIter=25000,
                           Tols=[(Domain.gap_rplus, 1e-6 * gap_0)])
        Repo = Reporting(Requests=[Domain.gap_rplus, 'Step', 'Data'])
        Misc = Miscellaneous()
        Options = DescentOptions(Init, Term, Repo, Misc)

        # Print Stats
        PrintSimStats(Domain, Method, Options)

        # Start Solver
        tic = time.time()
        Results = Solve(Start, Method, Domain, Options)
        toc = time.time() - tic

        # Print Results
        PrintSimResults(Options, Results, Method, toc)

        # Get Equilibrium Strategy
        Equilibrium = Results.PermStorage['Data'][-1]
        Equilibria[w] = Equilibrium

    # Matched Equilibria & Costs
    Equilibria_Matched = np.asarray([Equilibria[w] for w in Worlds])

    # Compute Mean of Equilibria
    Mean_Equilibrium = np.mean(Equilibria_Matched, axis=0)

    # Compute Strategies Distance From Mean Equilibrium
    Distance_From_Mean = np.linalg.norm(Strategies - Mean_Equilibrium, axis=1)

    # Plot Results
    fig = plt.figure()
    ax1 = fig.add_subplot(1, 1, 1)
    ax1.plot(Distance_From_Mean, label='Distance from Mean')
    ax1.set_title('Online Monotone Equilibration of Dynamic SOI Network')
    ax1.legend()
    ax1.set_xlabel('Time')

    plt.savefig('OMEfast.png')

    embed()