Some Experimental Features

This tutorial will go through a few experimental features that are made available but may not be fully tested and should note be relied upon.

using ACEpotentials

We do a quick fit of a TiAl potential following the same steps as in the TiAl model tutorial.

model = acemodel(elements = [:Ti, :Al], order = 3, totaldegree = 6,
					  rcut = 5.5, Eref = [:Ti => -1586.0195, :Al => -105.5954])
weights = Dict("FLD_TiAl" => Dict("E" => 60.0, "F" => 1.0 , "V" => 1.0 ),
               "TiAl_T5000" => Dict("E" => 5.0, "F" => 1.0 , "V" => 1.0 ))
solver = ACEfit.LSQR(damp = 1e-2, atol = 1e-6);
P = smoothness_prior(model; p = 4)
data, _, meta = ACEpotentials.example_dataset("TiAl_tutorial")
data_train = data[1:5:end]
acefit!(model, data_train; solver=solver, prior = P);

┌────────────┬──────────┬───────┬────┬──────┬─────┐
│       Type │ #Configs │ #Envs │ #E │   #F │  #V │
├────────────┼──────────┼───────┼────┼──────┼─────┤
│   FLD_TiAl │       63 │   126 │ 63 │  378 │ 378 │
│ TiAl_T5000 │        3 │   310 │  3 │  930 │  18 │
├────────────┼──────────┼───────┼────┼──────┼─────┤
│      total │       66 │   436 │ 66 │ 1308 │ 396 │
│    missing │        0 │     0 │  0 │    0 │   0 │
└────────────┴──────────┴───────┴────┴──────┴─────┘
[ Info: Assembling linear problem.
[ Info:   - Creating feature matrix with size (1770, 190).
[ Info:   - Beginning assembly with processor count:  1.

Progress:   3%|█▎                                       |  ETA: 0:00:28
Progress:   8%|███▏                                     |  ETA: 0:00:23
Progress:  12%|█████                                    |  ETA: 0:00:21
Progress:  17%|██████▉                                  |  ETA: 0:00:19
Progress:  21%|████████▊                                |  ETA: 0:00:18
Progress:  26%|██████████▌                              |  ETA: 0:00:17
Progress:  30%|████████████▍                            |  ETA: 0:00:16
Progress:  35%|██████████████▎                          |  ETA: 0:00:15
Progress:  39%|████████████████▏                        |  ETA: 0:00:14
Progress:  44%|██████████████████                       |  ETA: 0:00:13
Progress:  48%|███████████████████▉                     |  ETA: 0:00:12
Progress:  53%|█████████████████████▊                   |  ETA: 0:00:10
Progress:  58%|███████████████████████▋                 |  ETA: 0:00:09
Progress:  62%|█████████████████████████▌               |  ETA: 0:00:08
Progress:  67%|███████████████████████████▍             |  ETA: 0:00:07
Progress:  71%|█████████████████████████████▎           |  ETA: 0:00:06
Progress:  76%|███████████████████████████████          |  ETA: 0:00:05
Progress:  80%|████████████████████████████████▉        |  ETA: 0:00:04
Progress:  85%|██████████████████████████████████▊      |  ETA: 0:00:03
Progress:  89%|████████████████████████████████████▋    |  ETA: 0:00:02
Progress:  94%|██████████████████████████████████████▌  |  ETA: 0:00:01
Progress:  98%|████████████████████████████████████████▍|  ETA: 0:00:00
Progress: 100%|█████████████████████████████████████████| Time: 0:00:22
[ Info:   - Assembly completed.
[ Info: Assembling full weight vector.
┌ Warning: Need to apply preconditioner in LSQR.
└ @ ACEfit ~/.julia/packages/ACEfit/9u2t5/src/solvers.jl:94
damp  0.01
atol  1.0e-6
maxiter  100000
Converged after 270 iterations.
relative RMS error  0.0043518320952467835

Next we convert the model to a new experimental evaluator that should be a lot faster - at least for small models.

fpot = ACEpotentials.Experimental.fast_evaluator(model);

[ Info: Importing pair potential model
[ Info: Importing many-body potential
[ Info: Importing 1-body potential

The predictions should be correct to within 10-13 digits.

for ntest = 1:10
   at = rattle!(rand(data), 0.01)
   E = energy(model.potential, at)
   E_fast = energy(fpot, at)
   @show abs(E - E_fast)
end;

abs(E - E_fast) = 2.2737367544323206e-13
abs(E - E_fast) = 2.2737367544323206e-13
abs(E - E_fast) = 0.0
abs(E - E_fast) = 0.0
abs(E - E_fast) = 0.0
abs(E - E_fast) = 2.2737367544323206e-13
abs(E - E_fast) = 2.2737367544323206e-13
abs(E - E_fast) = 0.0
abs(E - E_fast) = 0.0
abs(E - E_fast) = 0.0

Now let's look at timings, they should be significantly faster for the new evaluator. Note that the speedup will be different depending on the size of the model and the architecture of the computer.

forces(model.potential, data[1]);
forces(fpot, data[1]);
print("Energy, old evaluator: ")
@time for d in data; energy(model.potential, d); end
print("Energy, new evaluator: ")
@time for d in data; energy(fpot, d); end
print("Forces, old evaluator: ")
@time for d in data; forces(model.potential, d); end
print("Forces, new evaluator: ")
@time for d in data; forces(fpot, d); end

Energy, old evaluator:   0.114010 seconds (2.00 M allocations: 92.589 MiB, 18.23% gc time)
Energy, new evaluator:   0.012860 seconds (1.65 k allocations: 479.297 KiB)
Forces, old evaluator:   0.176784 seconds (4.32 M allocations: 151.543 MiB, 9.89% gc time)
Forces, new evaluator:   0.028548 seconds (5.49 k allocations: 3.536 MiB)

This page was generated using Literate.jl.