Merge pull request ACEsuit#265 from ACEsuit/testtut

Final Cleanup Before Registering 0.8.0

Author: cortner

docs/src/tutorials/basic_julia_workflow.jl

@@ -67,12 +67,12 @@ result = acefit!(train_data, model; solver=solver, prior = P, weights=weights);
 # We can display an error table as follows:
 
 @info("Training Error Table")
-err_train = ACEpotentials.linear_errors(train_data, model; weights=weights);
+err_train = ACEpotentials.compute_errors(train_data, model; weights=weights);
 
 # We should of course also look at test errors, which can be done as follows. Depending on the choice of solver, and solver parameters, the test errors might be very poor. Exploring different parameters in different applications can lead to significantly improved predictions. 
 
 @info("Test Error Table")
-err_test = ACEpotentials.linear_errors(test_data, model; weights=weights);
+err_test = ACEpotentials.compute_errors(test_data, model; weights=weights);
 
 # If we want to save the fitted potentials to disk to later use we can simply save the hyperparameters and the parameters. At the moment this must be done manually but a more complete and convenient interface for this will be provided, also adding various sanity checks. 
 

docs/src/tutorials/smoothness_priors.jl

@@ -61,7 +61,7 @@ for (prior_name, P) in priors
     set_parameters!(_modl, P \ c̃)
 
     ## compute errors and store them for later use (don't print them here)
-    errs = linear_errors(rawdata, model; verbose=false, datakeys...)
+    errs = compute_errors(rawdata, model; verbose=false, datakeys...)
     rmse[prior_name] = errs["rmse"]["set"]["F"]
     pots[prior_name] = _modl
     println(" force=rmse = ", rmse[prior_name])

docs/src_outdated/AtomsBase_interface.md

@@ -60,7 +60,7 @@ P = smoothness_prior(model; p = 4)
 acefit!(model, data_train; solver=solver, weights=weights, prior = P);
 
 @info("Training Error Table")
-ACEpotentials.linear_errors(data_train, model; weights=weights);
+ACEpotentials.compute_errors(data_train, model; weights=weights);
 ```
 
 ### Training data in AtomsBase structures

docs/src_outdated/TiAl_basis.jl

@@ -76,10 +76,10 @@ test = [ACEpotentials.AtomsData(t; weights=weights, v_ref=Vref, datakeys...) for
 
 @info("Test Error Tables")
 @info("First Potential: ")
-ACEpotentials.linear_errors(test, pot_1);
+ACEpotentials.compute_errors(test, pot_1);
 
 @info("Second Potential: ")
-ACEpotentials.linear_errors(test, pot_2);
+ACEpotentials.compute_errors(test, pot_2);
 
 # If we want to save the fitted potentials to disk to later use we can use one of the following commands: the first saves the potential as an `ACE1.jl` compatible potential, while the second line exports it to a format that can be ready by the `pacemaker` code to be used within LAMMPS. This functionality is currently disabled.
 # 

docs/src_outdated/first_example_model.jl

@@ -51,15 +51,15 @@ acefit!(model, train; solver=solver, data_keys...);
 # To see the training errors we can use 
 
 @info("Training Errors")
-ACEpotentials.linear_errors(train, model; data_keys...);
+ACEpotentials.compute_errors(train, model; data_keys...);
 
 # ### Step 4: Run some tests 
 #
 # At a minimum one should have a test set, check the errors on that test set, and confirm that they are similar as the training errors. 
 
 @info("Test Errors")
 test =  [gen_dat() for _=1:20]
-ACEpotentials.linear_errors(test, model; data_keys...);
+ACEpotentials.compute_errors(test, model; data_keys...);
 
 # If we wanted to perform such a test ``manually'' it might look like this: 
 

examples/Tutorial/ACEpotentials-Tutorial.jl

@@ -25,12 +25,12 @@ Pkg.add(["LaTeXStrings", "MultivariateStats", "Plots", "PrettyTables",
          "Suppressor", "ExtXYZ", "Unitful", "Distributed", "AtomsCalculators", 
          ])
 
-## ACEpotentials installation 
-using Pkg
-Pkg.activate(".")
+## ACEpotentials installation:  
+## If ACEpotentials has not been installed yet, uncomment the following lines
+## using Pkg; Pkg.activate(".")
 ## Add the ACE registry, which stores the ACEpotential package information 
-Pkg.Registry.add(RegistrySpec(url="https://github.com/ACEsuit/ACEregistry"))
-Pkg.add("ACEpotentials")
+## Pkg.Registry.add(RegistrySpec(url="https://github.com/ACEsuit/ACEregistry"))
+## Pkg.add("ACEpotentials")
 
 #   We can check the status of the installed packages.
 
@@ -247,10 +247,10 @@ acefit!(Si_tiny_dataset, model;
         solver=solver, data_keys...);
 
 @info("Training Errors")
-linear_errors(Si_tiny_dataset, model; data_keys...);
+compute_errors(Si_tiny_dataset, model; data_keys...);
 
 @info("Test Error")
-linear_errors(Si_dataset, model; data_keys...);
+compute_errors(Si_dataset, model; data_keys...);
 
 #   Export to LAMMPS is currently not supported. Earlier versions of
 #   `ACEpotentials` supported this via
@@ -376,6 +376,7 @@ assess_model(new_model, new_dataset)
 #   structures in total.
 
 for i in 1:4
+    global new_dataset, new_model # declare these are global variables 
     @show i
     new_dataset, new_model = augment(new_dataset, new_model; num=5);
 end
@@ -424,7 +425,7 @@ model = ace1_model(elements = [:Ti, :Al],
 #   and it is fit in the same manner.
 
 acefit!(tial_data[1:5:end], model);
-linear_errors(tial_data[1:5:end], model);
+compute_errors(tial_data[1:5:end], model);
 
 #   ## Part 6: Recreate data from the ACEpotentials.jl paper
 # 
@@ -455,6 +456,7 @@ totaldegree = [ 20, 16, 12 ]  # small model: ~ 300  basis functions
 errors = Dict("E" => Dict(), "F" => Dict())
 
 for element in elements 
+    local model  # treat `model` as a variable local to the scope of `for`
     ## load the dataset
     @info("---------- loading $(element) dataset ----------")
     train, test, _ = ACEpotentials.example_dataset("Zuo20_$element")
@@ -464,7 +466,7 @@ for element in elements
     ## train the model 
     acefit!(train, model, solver = ACEfit.BLR(; factorization = :svd))
     ## compute and store errors
-    err  = linear_errors(test,  model)
+    err  = compute_errors(test,  model)
     errors["E"][element] = err["mae"]["set"]["E"] * 1000
     errors["F"][element] = err["mae"]["set"]["F"]
 end
@@ -523,4 +525,4 @@ pretty_table(f_table; header = header)
 #   -  Use an `ACEpotentials.jl` potential with ASE:
 #        https://acesuit.github.io/ACEpotentials.jl/dev/tutorials/python_ase/
 #   -  Install LAMMPS with `ACEpotentials` patch:
-#        https://acesuit.github.io/ACEpotentials.jl/dev/tutorials/lammps/
+#        https://acesuit.github.io/ACEpotentials.jl/dev/tutorials/lammps/

examples/zuobench/error_table.jl

@@ -33,8 +33,8 @@ for sym in syms
    acefit!(train, model_lge; solver=solver); GC.gc() 
 
    # compute and store errors for later visualisation
-   err_sm  = ACEpotentials.linear_errors(test, model_sm)
-   err_lge = ACEpotentials.linear_errors(test, model_lge)
+   err_sm  = ACEpotentials.compute_errors(test, model_sm)
+   err_lge = ACEpotentials.compute_errors(test, model_lge)
    err["sm" ]["E"][sym] =  err_sm["mae"]["set"]["E"] * 1000
    err["sm" ]["F"][sym] =  err_sm["mae"]["set"]["F"]
    err["lge"]["E"][sym] = err_lge["mae"]["set"]["E"] * 1000

examples/zuobench/error_table_svd.jl

@@ -35,8 +35,8 @@ for sym in syms
    acefit!(train, model_lge; solver=solver); GC.gc() 
 
    # compute and store errors for later visualisation
-   err_sm  = ACEpotentials.linear_errors(test, model_sm)
-   err_lge = ACEpotentials.linear_errors(test, model_lge)
+   err_sm  = ACEpotentials.compute_errors(test, model_sm)
+   err_lge = ACEpotentials.compute_errors(test, model_lge)
    err["sm_blr" ]["E"][sym] =  err_sm["mae"]["set"]["E"] * 1000
    err["sm_blr" ]["F"][sym] =  err_sm["mae"]["set"]["F"]
    err["lge_blr"]["E"][sym] = err_lge["mae"]["set"]["E"] * 1000
@@ -50,8 +50,8 @@ for sym in syms
    solver = ACEfit.TruncatedSVD()   # truncation will be determined from validation set 
    acefit!(train1, model_sm;  validation_set = val1, solver=solver); GC.gc()
    acefit!(train1, model_lge; validation_set = val1, solver=solver); GC.gc() 
-   err_sm  = ACEpotentials.linear_errors(test, model_sm)
-   err_lge = ACEpotentials.linear_errors(test, model_lge)
+   err_sm  = ACEpotentials.compute_errors(test, model_sm)
+   err_lge = ACEpotentials.compute_errors(test, model_lge)
    err["sm_svd" ]["E"][sym] =  err_sm["mae"]["set"]["E"] * 1000
    err["sm_svd" ]["F"][sym] =  err_sm["mae"]["set"]["F"]
    err["lge_svd"]["E"][sym] = err_lge["mae"]["set"]["E"] * 1000

examples/zuobench/zuo_asp.jl

@@ -55,9 +55,9 @@ pot_300 = fast_evaluator(model_300; aa_static = true)
 pot_100 = fast_evaluator(model_100; aa_static = true)
 
 @info("Evaluate errors on the test set") 
-err_100 = ACEpotentials.linear_errors(test_data,  pot_100)
-err_300 = ACEpotentials.linear_errors(test_data,  pot_300)
-err_1000 = ACEpotentials.linear_errors(test_data, pot_1000)
+err_100 = ACEpotentials.compute_errors(test_data,  pot_100)
+err_300 = ACEpotentials.compute_errors(test_data,  pot_300)
+err_1000 = ACEpotentials.compute_errors(test_data, pot_1000)
 
 ##
 

ext_tests/tutorial/run_tutorial.jl

@@ -0,0 +1,29 @@
+# Run this test using 
+#   julia --project=. run_tutorial.jl 
+# if the command fails, then clean the folder using 
+#   rm ACEpotentials-Tutorial.jl ACEpotentials-Tutorial.ipynb Project.toml Manifest.toml Si_dataset.xyz Si_tiny_tutorial.json
+
+julia_cmd = Base.julia_cmd()
+appath = abspath(joinpath(@__DIR__(), "..", ".."))
+setuptutorial = """
+   begin 
+      using Pkg; 
+      Pkg.develop(; path = \"$appath\"); 
+      using ACEpotentials; 
+      ACEpotentials.copy_tutorial();
+   end
+"""
+
+run(`$julia_cmd --project=. -e $setuptutorial`)
+
+if !isfile("ACEpotentials-Tutorial.ipynb")
+   error("Tutorial notebook not installed.")
+end
+
+tutorial_file = joinpath(appath, "examples", "Tutorial", "ACEpotentials-Tutorial.jl")
+cp(tutorial_file, joinpath(pwd(), "ACEpotentials-Tutorial.jl"); force=true)
+
+run(`$julia_cmd --project=. ACEpotentials-Tutorial.jl`)
+
+@info("Cleaning up")
+run(`rm ACEpotentials-Tutorial.jl ACEpotentials-Tutorial.ipynb Project.toml Manifest.toml Si_dataset.xyz Si_tiny_tutorial.json`)