pwact 0.1.27__py3-none-any.whl → 0.2.0__py3-none-any.whl

pwact/active_learning/environment.py

@@ -2,15 +2,17 @@ import subprocess
 import pkg_resources
 def check_envs():
     # for pwmat
-    pass
-    # check pwdata
-    # try:
-    #     package_version = pkg_resources.get_distribution('pwdata').version
-    #     if pkg_resources.parse_version(min_version) <= pkg_resources.parse_version(package_version) <= pkg_resources.parse_version(max_version):
-    #         print(f"{package_name} version {package_version} is within the required range [{min_version}, {max_version}].")
-    #         return True
-    #     else:
-    #         print(f"{package_name} version {package_version} is NOT within the required range [{min_version}, {max_version}].")
-    #         return False
+    comm_info()
 
-    # check PWMLFF???
+def comm_info():
+    print("\n" + "=" * 50) 
+    print("         PWACT Basic Information")
+    print("=" * 50) 
+    print("Version: 0.2.0")
+    print("Compatible pwdata: >= 0.5.0")
+    print("Compatible MatPL: >= 2025.3")
+    print("Contact: support@pwmat.com")
+    print("Citation: https://github.com/LonxunQuantum/MatPL")
+    print("Manual online: http://doc.lonxun.com/PWMLFF/")
+    print("=" * 50)  
+    print("\n\n")

pwact/active_learning/explore/run_model_md.py

@@ -16,7 +16,7 @@
             ...
 """
 from pwact.active_learning.slurm.slurm import Mission, SlurmJob, scancle_job
-from pwact.utils.slurm_script import get_slurm_job_run_info, split_job_for_group, set_slurm_script_content
+from pwact.utils.slurm_script import get_slurm_job_run_info, split_job_for_group, set_slurm_script_content, recheck_slurm_by_jobtag
 from pwact.active_learning.explore.select_image import select_image
 from pwact.active_learning.user_input.resource import Resource
 from pwact.active_learning.user_input.iter_input import InputParam, MdDetail
@@ -175,14 +175,17 @@ class Explore(object):
         slurm_remain, slurm_success = get_slurm_job_run_info(self.md_dir, \
             job_patten="*-{}".format(EXPLORE_FILE_STRUCTURE.md_job), \
             tag_patten="*-{}".format(EXPLORE_FILE_STRUCTURE.md_tag))
+        # for slurm remain, check if tags done
         slurm_done = True if len(slurm_remain) == 0 and len(slurm_success) > 0 else False
         if slurm_done is False:
+            slurm_remain = recheck_slurm_by_jobtag(slurm_remain, EXPLORE_FILE_STRUCTURE.md_tag)
+        if len(slurm_remain) > 0:
             #recover slurm jobs
             if len(slurm_remain) > 0:
                 print("Run these MD Jobs:\n")
                 print(slurm_remain)
                 for i, script_path in enumerate(slurm_remain):
-                    slurm_job = SlurmJob()
+                    slurm_job = SlurmJob(lmps_tolerance = self.input_param.strategy.lmps_tolerance)
                     tag_name = "{}-{}".format(os.path.basename(script_path).split('-')[0].strip(), EXPLORE_FILE_STRUCTURE.md_tag)
                     tag = os.path.join(os.path.dirname(script_path),tag_name)
                     slurm_job.set_tag(tag, job_type=SLURM_JOB_TYPE.lammps)

pwact/active_learning/explore/select_image.py

@@ -3,7 +3,7 @@ import os
 
 import pandas as pd
 import numpy as  np
-from pwact.utils.constant import EXPLORE_FILE_STRUCTURE, UNCERTAINTY
+from pwact.utils.constant import EXPLORE_FILE_STRUCTURE, UNCERTAINTY, SLURM_OUT
 from pwact.utils.file_operation import write_to_file, search_files, read_data
 
 from pwact.utils.format_input_output import get_sub_md_sys_template_name
@@ -79,7 +79,7 @@ def select_image(
     devi_name:str,
     lower:float, 
     higer:float
-):
+):  
     #1. get model_deviation file
     model_deviation_patten = "{}/{}".format(get_sub_md_sys_template_name(), devi_name)
     model_devi_files = search_files(md_dir, model_deviation_patten)
@@ -108,14 +108,22 @@ def select_image(
             accurate_pd = pd.concat([accurate_pd, tmp_accurate_pd]) if error_pd is not None else tmp_accurate_pd
             rand_candi = pd.concat([rand_candi, tmp_rand_candi]) if error_pd is not None else tmp_rand_candi
             remove_candi = pd.concat([remove_candi, tmp_remove_candi]) if error_pd is not None else tmp_remove_candi
-    summary_info, summary = count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi)
+    right_md, error_md = count_mdstop_info(model_devi_files)
+    md_run_info = "A total of {} MD trajectories were run. with {} trajectories correctly executed and {} trajectories normally completed. \nFor detailed information, refer to File {}.".format(len(right_md) + len(error_md), len(right_md), len(error_md), EXPLORE_FILE_STRUCTURE.md_traj_error_record)
     
-    # summary_info, summary = select_image(save_dir=self.select_dir, 
-    #                 devi_pd=devi_pd, 
-    #                 lower=self.input_param.strategy.lower_model_deiv_f, 
-    #                 higer=self.input_param.strategy.upper_model_deiv_f, 
-    #                 max_select=self.input_param.strategy.max_select)
+    summary_info, summary = count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi, md_run_info)
     print("Image select result:\n {}\n\n".format(summary_info))
+
+    write_to_file(os.path.join(save_dir, EXPLORE_FILE_STRUCTURE.md_traj_error_record), md_run_info, "w")
+    details = "\n"
+    if len(error_md) > 0:
+        details += "\nUnfinished md trajectory directory:\n"
+        details += "\n".join(error_md)
+    if len(right_md) > 0:
+        details += "\n\nCorrectly run md trajectory directory:\n"
+        details += "\n".join(right_md)
+    write_to_file(os.path.join(save_dir, EXPLORE_FILE_STRUCTURE.md_traj_error_record), details, "a")
+
     return summary
 
 def print_select_image(
@@ -211,7 +219,7 @@ def read_pd_files(model_devi_files:list[str]):
     return devi_pd, base_force_kpu
 
 
-def count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi):
+def count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi, md_run_info:str=None):
     #5. save select info
     total_num = error_pd.shape[0] + accurate_pd.shape[0] + rand_candi.shape[0] + remove_candi.shape[0]
     cand_num = rand_candi.shape[0] + remove_candi.shape[0]
@@ -233,9 +241,14 @@ def count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi):
     summary_info += "Accurate configurations: {}, details in file {}\n".\
         format(accurate_pd.shape[0], EXPLORE_FILE_STRUCTURE.accurate)
     summary_info += candi_info
-    summary_info += "Error configurations: {}, details in file {}\n".\
+    summary_info += "Error configurations: {}, details in file {}\n\n".\
         format(error_pd.shape[0], EXPLORE_FILE_STRUCTURE.failed)
+    if md_run_info is not None:
+        summary_info += md_run_info
+        summary_info += "\n\n"
 
+        summary += md_run_info 
+        summary += "\n"
     if save_dir is not None:
         if not os.path.exists(save_dir):
             os.makedirs(save_dir)
@@ -249,3 +262,29 @@ def count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi):
     return summary_info, summary
 
 
+def count_mdstop_info(devi_file_list):
+    def read_md_last_line(md_log):
+        with open(md_log, "rb") as file:
+            file.seek(-2, 2)  # 定位到文件末尾前两个字节
+            while file.read(1) != b'\n':  # 逐字节向前查找换行符
+                file.seek(-2, 1)  # 向前移动两个字节
+            last_line = file.readline().decode().strip()  # 读取最后一行并去除换行符和空白字符
+        if "Total wall time" in last_line: #md 正常结束
+            return True
+        else:
+            return False
+    # for each md model_deviation file get shape
+    # for each md md.log get run time 
+    # do compare
+    right_list = []
+    error_list = []
+    for devi_file in devi_file_list:
+        devi = np.loadtxt(devi_file)
+        end_normal = read_md_last_line(os.path.join(os.path.dirname(devi_file), SLURM_OUT.md_out))
+        if end_normal and devi.shape[0] > 1:
+            right_list.append(os.path.dirname(devi_file))
+        else:
+            error_list.append(os.path.dirname(devi_file))
+    return right_list, error_list
+
+    

pwact/active_learning/init_bulk/init_bulk_run.py

@@ -9,7 +9,7 @@ from pwact.active_learning.init_bulk.relabel import Relabel
 from pwact.active_learning.user_input.init_bulk_input import InitBulkParam
 from pwact.active_learning.user_input.resource import Resource
 from pwact.active_learning.slurm.slurm import scancle_job
-from pwact.utils.constant import INIT_BULK, DFT_STYLE, TEMP_STRUCTURE
+from pwact.utils.constant import INIT_BULK, DFT_STYLE, TEMP_STRUCTURE, PWDATA
 from pwact.utils.file_operation import copy_file, copy_dir, search_files, del_file, del_file_list, write_to_file
 from pwact.data_format.configop import extract_pwdata
 
@@ -104,13 +104,13 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
                 continue
             source_aimd = sorted(source_aimd)
             #5. convert the aimd files (for vasp is outcar, for pwmat is movement) to npy format
-            extract_pwdata(data_list=source_aimd, 
-                    data_format=DFT_STYLE.get_aimd_config_format(resource.dft_style),
-                    datasets_path=os.path.join(collection_dir, init_config_name, INIT_BULK.npy_format_save_dir), 
-                    train_valid_ratio=input_param.train_valid_ratio, 
-                    data_shuffle=input_param.data_shuffle, 
-                    merge_data=True,
-                    interval=1
+            extract_pwdata(input_data_list=source_aimd, 
+                            intput_data_format= DFT_STYLE.get_aimd_config_format(resource.dft_style),
+                            save_data_path  = os.path.join(collection_dir, init_config_name),
+                            save_data_name  = INIT_BULK.get_save_format(input_param.data_format), 
+                            save_data_format= input_param.data_format,
+                            data_shuffle=input_param.data_shuffle, 
+                            interval=1
                 )
 
         #6 convert relabel datas
@@ -122,12 +122,12 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
                 continue
             source_scf = sorted(source_scf, key=lambda x:int(os.path.basename(os.path.dirname(x)).split('-')[0]), reverse=False)
             #5. convert the aimd files (for vasp is outcar, for pwmat is movement) to npy format
-            extract_pwdata(data_list=source_scf, 
-                    data_format=DFT_STYLE.get_format_by_postfix(os.path.basename(source_scf[0])),
-                    datasets_path=os.path.join(collection_dir, init_config_name, "scf_pwdata"), 
-                    train_valid_ratio=input_param.train_valid_ratio, 
+            extract_pwdata(input_data_list=source_scf, 
+                    intput_data_format= DFT_STYLE.get_format_by_postfix(os.path.basename(source_scf[0])),
+                    save_data_path  = os.path.join(collection_dir, init_config_name), 
+                    save_data_name  = INIT_BULK.get_save_format(input_param.data_format), 
+                    save_data_format= input_param.data_format,
                     data_shuffle=input_param.data_shuffle, 
-                    merge_data=True,
                     interval=1
                 )
 
@@ -146,7 +146,11 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
         del_file_list([temp_work_dir])
 
     # print the dir of pwdatas from aimd
-    pwdatas = search_files(real_collection_dir, "*/{}".format(INIT_BULK.npy_format_save_dir))
+    if input_param.data_format == PWDATA.extxyz:
+        pwdatas = search_files(real_collection_dir, "*/{}".format(INIT_BULK.get_save_format(input_param.data_format)))
+    elif input_param.data_format == PWDATA.pwmlff_npy: # */PWdata/*.npy
+        tmp = search_files(real_collection_dir, "*/{}/*/position.npy".format(INIT_BULK.get_save_format(input_param.data_format)))
+        pwdatas = [os.path.dirname(_) for _ in tmp]
     if len(pwdatas) > 0:
         pwdatas = sorted(pwdatas)
         result_lines = ["\"{}\",".format(_) for _ in pwdatas]

pwact/active_learning/label/labeling.py

@@ -27,7 +27,7 @@ from pwact.active_learning.user_input.iter_input import InputParam
 from pwact.active_learning.slurm.slurm import SlurmJob, Mission, scancle_job
 
 from pwact.utils.constant import DFT_TYPE, VASP, PWDATA, AL_STRUCTURE, TEMP_STRUCTURE,\
-    LABEL_FILE_STRUCTURE, EXPLORE_FILE_STRUCTURE, LAMMPS, SLURM_OUT, DFT_STYLE, PWMAT
+    LABEL_FILE_STRUCTURE, EXPLORE_FILE_STRUCTURE, LAMMPS, SLURM_OUT, DFT_STYLE, PWMAT, INIT_BULK
     
 from pwact.utils.slurm_script import get_slurm_job_run_info, split_job_for_group, set_slurm_script_content
 from pwact.utils.format_input_output import get_iter_from_iter_name, get_md_sys_template_name
@@ -280,22 +280,12 @@ class Labeling(object):
         # scf files to pwdata format
         scf_configs = self.collect_scf_configs()
 
-        extract_pwdata(data_list=scf_configs,
-                data_format      =DFT_STYLE.get_format_by_postfix(os.path.basename(scf_configs[0])),
-                datasets_path    =self.result_dir,
-                train_valid_ratio=self.input_param.train.train_valid_ratio, 
-                data_shuffle     =self.input_param.train.data_shuffle, 
-                merge_data       =True
+        extract_pwdata(input_data_list=scf_configs,
+                intput_data_format =DFT_STYLE.get_format_by_postfix(os.path.basename(scf_configs[0])),
+                save_data_path =self.result_dir,
+                save_data_name = INIT_BULK.get_save_format(self.input_param.data_format),
+                save_data_format = self.input_param.data_format,
+                data_shuffle     =self.input_param.train.data_shuffle
         )
-
-        # for id, scf_md in enumerate(scf_configs):
-        #     datasets_path_name = os.path.basename(os.path.dirname(os.path.dirname(scf_md[0])))#md.001.sys.001.t.000.p.000
-        #     extract_pwdata(data_list=scf_md,
-        #         data_format      =DFT_STYLE.get_format_by_postfix(os.path.basename(scf_md[0])),
-        #         datasets_path    =os.path.join(self.result_dir, "{}-{}".format(id, datasets_path_name)),
-        #         train_valid_ratio=self.input_param.train.train_valid_ratio, 
-        #         data_shuffle     =self.input_param.train.data_shuffle, 
-        #         merge_data       =True
-        #     )
         # copy to main dir
         copy_dir(self.result_dir, self.real_result_dir)

pwact/active_learning/slurm/slurm.py

@@ -4,6 +4,8 @@ import os
 import sys
 import time
 import shutil
+import numpy as np
+from pwact.utils.constant import EXPLORE_FILE_STRUCTURE
 from pwact.active_learning.slurm.slurm_tool import get_jobs
 class JobStatus (Enum) :
     unsubmitted = 1 #
@@ -20,7 +22,7 @@ def get_slurm_sbatch_cmd(job_dir:str, job_name:str):
     return cmd
 
 class SlurmJob(object):
-    def __init__(self, job_id=None, status=JobStatus.unsubmitted, user=None, name=None, nodes=None, nodelist=None, partition=None) -> None:
+    def __init__(self, job_id=None, status=JobStatus.unsubmitted, user=None, name=None, nodes=None, nodelist=None, partition=None, lmps_tolerance:bool=True) -> None:
         self.job_id = job_id
         self.status = status
         self.user = user
@@ -29,6 +31,7 @@ class SlurmJob(object):
         self.nodes = nodes
         self.nodelist = nodelist
         self.submit_num = 0
+        self.lmps_tolerance = True
         
     def set_cmd(self, script_path:str):
         #such as "sbatch main_MD_test.sh"
@@ -186,24 +189,36 @@ class SlurmJob(object):
                 md_log = os.path.join(md_dir, "md.log")
                 if os.path.exists(tag_md_file):
                     continue
-                if not os.path.exists(md_log):
-                    return False
 
+                # check if has error
                 with open(md_log, "rb") as file:
                     file.seek(-2, 2)  # 定位到文件末尾前两个字节
                     while file.read(1) != b'\n':  # 逐字节向前查找换行符
                         file.seek(-2, 1)  # 向前移动两个字节
                     last_line = file.readline().decode().strip()  # 读取最后一行并去除换行符和空白字符
-                if "ERROR: there are two atoms" in last_line:
-                    with open(tag_md_file, 'w') as wf:
-                        wf.writelines("ERROR: there are two atoms too close")
-                    return True
-                elif "Total wall time" in last_line:
+                if "Total wall time" in last_line: #md 正常结束
                     with open(tag_md_file, 'w') as wf:
                         wf.writelines("Job Done!")
                     return True
-                else:
+
+                if os.path.exists(os.path.join(md_dir, EXPLORE_FILE_STRUCTURE.model_devi)):
+                    devi = np.loadtxt(os.path.join(md_dir, EXPLORE_FILE_STRUCTURE.model_devi))
+                    if self.lmps_tolerance and devi.shape[0] > 0:
+                        with open(tag_md_file, 'w') as wf:
+                            wf.writelines("Job Done!")
+                        return True
+                    else:
+                        return False
+                else: # md运行中非正常结束
                     return False
+
+                # check model_devi.out
+                # elif "ERROR: there are two atoms" in last_line:
+                #     with open(tag_md_file, 'w') as wf:
+                #         wf.writelines("ERROR: there are two atoms too close")
+                #     return True
+                # else:
+                #     return False
             return True
         except Exception as e:
             return False
@@ -380,3 +395,16 @@ def scancle_job(work_dir:str):
         else:
             print("Scancel job {} failed, Please manually check and cancel this task!\n".format(job_id))
 
+def scancle_byjobid(job_id):
+    job = SlurmJob(job_id=job_id)
+    status = job.check_status_no_tag()#get status
+    if status == JobStatus.waiting or status == JobStatus.running: # is running 
+        job.scancel_job()
+    time.sleep(5)
+    job = SlurmJob(job_id=job_id)
+    status = job.check_status_no_tag()#get status
+    if JobStatus.finished == status:
+        print("scancel job {} successfully".format(job_id))
+    else:
+        print("Scancel job {} failed, Please manually check and cancel this task!\n".format(job_id))
+

pwact/active_learning/train/train_model.py

@@ -9,7 +9,7 @@ from pwact.active_learning.user_input.iter_input import InputParam
 
 from pwact.utils.format_input_output import make_train_name, get_seed_by_time, get_iter_from_iter_name, make_iter_name
 from pwact.utils.constant import AL_STRUCTURE, UNCERTAINTY, TEMP_STRUCTURE, MODEL_CMD, \
-    TRAIN_INPUT_PARAM, TRAIN_FILE_STRUCTUR, FORCEFILED, LABEL_FILE_STRUCTURE, SLURM_OUT, MODEL_TYPE
+    TRAIN_INPUT_PARAM, TRAIN_FILE_STRUCTUR, FORCEFILED, LABEL_FILE_STRUCTURE, SLURM_OUT, MODEL_TYPE, PWDATA, INIT_BULK
 
 from pwact.utils.file_operation import save_json_file, write_to_file, del_dir, search_files, add_postfix_dir, mv_file, copy_dir, del_file_list, del_file_list_by_patten
 '''
@@ -68,7 +68,7 @@ class ModelTrian(object):
             if not os.path.exists(model_i_dir):
                 os.makedirs(model_i_dir)
             # make train.json file
-            train_dict = self.set_train_input_dict(work_dir=model_i_dir)
+            train_dict = self.set_train_input_dict(work_dir=model_i_dir, model_index = model_index)
             train_json_file_path = os.path.join(model_i_dir, TRAIN_FILE_STRUCTUR.train_json)
             save_json_file(train_dict, train_json_file_path)
             train_list.append(model_i_dir)
@@ -139,33 +139,46 @@ class ModelTrian(object):
     return {*}
     author: wuxingxing
     '''
-    def set_train_input_dict(self, work_dir:str=None):
+    def set_train_input_dict(self, work_dir:str=None, model_index=None):
         train_json = self.input_param.train.to_dict()
-        train_feature_path = []
-        if self.input_param.init_data_only_pretrain and self.iter > 0:
+        if self.iter == 0 and len(self.input_param.init_model_list) > 0: 
+            train_json[TRAIN_INPUT_PARAM.recover_train] = True
+            train_json[TRAIN_INPUT_PARAM.model_load_file] = self.input_param.init_model_list[model_index]
+            train_json[TRAIN_INPUT_PARAM.optimizer][TRAIN_INPUT_PARAM.reset_epoch] = True            
+        if self.iter > 0 and self.input_param.use_pre_model:
             # use old model param iter.*/train/train.000/model_record/dp_model.ckpt
             pre_model = os.path.join(self.input_param.root_dir, make_iter_name(self.iter-1), \
                 AL_STRUCTURE.train, make_train_name(0), TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.dp_model_name)
             train_json[TRAIN_INPUT_PARAM.recover_train] = True
             train_json[TRAIN_INPUT_PARAM.model_load_file] = pre_model
             train_json[TRAIN_INPUT_PARAM.optimizer][TRAIN_INPUT_PARAM.reset_epoch] = True
-        else:
-            for _data in self.input_param.init_data:
-                train_feature_path.append(_data)
+        train_feature_path = []
+        for _data in self.input_param.init_data:
+            train_feature_path.append(_data)
         # search train_feature_path in iter*/label/result/*/PWdata/*
         iter_index = get_iter_from_iter_name(self.itername)
         start_iter = 0
         while start_iter < iter_index:
-            iter_pwdata = search_files(self.input_param.root_dir, 
-                                    "{}/{}/{}/*".format(make_iter_name(start_iter), AL_STRUCTURE.labeling, LABEL_FILE_STRUCTURE.result))
-            if len(iter_pwdata) > 0:
-                train_feature_path.extend(iter_pwdata)
+            if self.input_param.data_format == PWDATA.extxyz: # result/train.xyz
+                iter_data_list = search_files(self.input_param.root_dir, 
+                                    "{}/{}/{}/{}".format(make_iter_name(start_iter),
+                                         AL_STRUCTURE.labeling, LABEL_FILE_STRUCTURE.result, INIT_BULK.get_save_format(self.input_param.data_format)))
+            else:#pwmlff/npy 'iter.***/label/result/*/*' -> result/PWdata/dir
+                iter_data_list = search_files(self.input_param.root_dir, 
+                                    "{}/{}/{}/*/*".format(make_iter_name(start_iter),
+                                         AL_STRUCTURE.labeling, LABEL_FILE_STRUCTURE.result))
+
+            if len(iter_data_list) > 0:
+                train_feature_path.extend(iter_data_list)
             start_iter += 1
         
         # reset seed
         train_json[TRAIN_INPUT_PARAM.seed] = get_seed_by_time()
         train_json[TRAIN_INPUT_PARAM.raw_files] = []
-        train_json[TRAIN_INPUT_PARAM.datasets_path] = train_feature_path
+        train_json[TRAIN_INPUT_PARAM.train_data] = train_feature_path
+        # set valid data
+        train_json[TRAIN_INPUT_PARAM.valid_data] = self.input_param.valid_data
+        train_json[TRAIN_INPUT_PARAM.format] = self.input_param.data_format
         if self.input_param.strategy.uncertainty == UNCERTAINTY.kpu:
             train_json[TRAIN_INPUT_PARAM.save_p_matrix] = True
         return train_json

pwact/active_learning/user_input/init_bulk_input.py

@@ -11,8 +11,10 @@ class InitBulkParam(object):
         if not os.path.isabs(self.root_dir):
             self.root_dir = os.path.realpath(self.root_dir)
         
-        self.data_shuffle = get_parameter("data_shuffle", json_dict, True)
-        self.train_valid_ratio = get_parameter("train_valid_ratio", json_dict, 0.8)
+        self.data_shuffle = get_parameter("data_shuffle", json_dict, False)
+        self.data_format = get_parameter("data_format", json_dict, PWDATA.extxyz).lower()
+        if self.data_format not in [PWDATA.extxyz, PWDATA.pwmlff_npy]:
+            raise Exception("ERROR! The 'data_format' only support 'extxyz' or 'pwmlff/npy' format! The fefault format is 'extxyz'!")        
         self.interval = get_parameter("interval", json_dict, 1)
 
         # self.reserve_pwmat_files = get_parameter("reserve_pwmat_files", json_dict, False)

pwact/active_learning/user_input/iter_input.py

@@ -1,6 +1,6 @@
 import os
 import glob
-
+from pwact.utils.file_operation import check_model_type
 from pwact.utils.json_operation import get_parameter, get_required_parameter
 from pwact.utils.constant import MODEL_CMD, FORCEFILED, UNCERTAINTY, PWDATA
 from pwact.active_learning.user_input.train_param.train_param import InputParam as TrainParam
@@ -20,13 +20,28 @@ class InputParam(object):
         self.reserve_md_traj = get_parameter("reserve_md_traj", json_dict, False)   #
         self.reserve_scf_files = get_parameter("reserve_scf_files", json_dict, False) # not used
 
+        self.data_format = get_parameter("data_format", json_dict, "extxyz")
         init_data = get_parameter("init_data", json_dict, [])
         self.init_data = self.get_init_data(init_data)
+        init_valid_data= get_parameter("valid_data", json_dict, [])
+        self.valid_data = self.get_init_data(init_valid_data)
         # the init data for pretraining
-        self.init_data_only_pretrain = get_parameter("init_data_only_pretrain", json_dict, False)
-        
+        # self.init_data_only_pretrain = get_parameter("init_data_only_pretrain", json_dict, False)
         self.train = TrainParam(json_input=json_dict["train"], cmd=MODEL_CMD.train)
+        self.use_pre_model = get_parameter("use_pre_model", json_dict, True)
         self.strategy = StrategyParam(json_dict["strategy"])
+        #check_model_type: check type and nums
+        self.init_model_list = get_parameter("init_model_list", json_dict, [])
+        if len(self.init_model_list) > 0:
+            if len(self.init_model_list) != self.strategy.model_num:
+                raise Exception("Error! The number of input models needs to be consistent with model_num {} in 'strategy'".format(self.strategy.model_num))
+            for _model_file in self.init_model_list:
+                if not os.path.exists(_model_file):
+                    raise Exception("Error! The model in init_model_list {} does not exist".format(_model_file)) 
+                _model_type = check_model_type(_model_file)
+                if _model_type != self.train.model_type:
+                    raise Exception("Error! The model type in init_model_list is {}, should be consistent with model_type {} in 'train'".format(_model_type, self.train.model_type)) 
+            self.init_model_list = [os.path.abspath(_) for _ in self.init_model_list]
 
         if self.strategy.uncertainty == UNCERTAINTY.kpu and \
             self.train.optimizer_param.opt_name.upper() != "LKF":
@@ -63,7 +78,7 @@ class InputParam(object):
 class StrategyParam(object):
     def __init__(self, json_dict) -> None:
         self.md_type = get_parameter("md_type", json_dict, FORCEFILED.libtorch_lmps)
-        
+        self.lmps_tolerance = get_parameter("lmps_tolerance", json_dict, True)
         self.max_select = get_parameter("max_select", json_dict, None)
         self.uncertainty = get_parameter("uncertainty", json_dict, UNCERTAINTY.committee).upper()
         if self.uncertainty.upper() == UNCERTAINTY.kpu:

pwact/active_learning/user_input/scf_param.py

@@ -70,6 +70,7 @@ class SCFParam(object):
             potential_list = get_parameter("potential_list", gaussian_param, None)
             atom_list = get_parameter("atom_list", gaussian_param, None)
             self.gaussian_base_param = {}
+            self.gaussian_base_param["KSPACING"] = get_parameter("kspacing", gaussian_param, None)
             self.gaussian_base_param["ELEMENT"] = atom_list
             self.gaussian_base_param["BASIS_SET"] = basis_set_list
             self.gaussian_base_param["POTENTIAL"] = potential_list
@@ -79,6 +80,7 @@ class SCFParam(object):
             self.basis_set_file = None# os.path.abspath(get_parameter("basis_set_file", json_dict, None))
             self.potential_file = None#os.path.abspath(get_parameter("potential_file", json_dict, None))
             self.gaussian_base_param = None
+            self.kspacing = None
         # for cp2k and pwmat gaussion
         
 

pwact/active_learning/user_input/train_param/nep_param.py

@@ -250,11 +250,11 @@ class NepParam(object):
             error_log = "the input 'l_max' should has 3 values. The values should be [4, 0, 0] (only use three body features), [4, 2, 0] (use 3 and 4 body features) or [4, 2, 1] (use 3,4,5 body features).\n"
             raise Exception(error_log)
         if "fitting_net" in model_dict.keys():
-            self.neuron = self.get_parameter("network_size", model_dict["fitting_net"], [100]) # number of neurons in the hidden layer
+            self.neuron = self.get_parameter("network_size", model_dict["fitting_net"], [40]) # number of neurons in the hidden layer
             if not isinstance(self.neuron, list):
                 self.neuron = [self.neuron]
         else:
-            self.neuron = [100]
+            self.neuron = [40]
         if self.neuron[-1] != 1:
             self.neuron.append(1) # output layer of fitting net
         self.set_feature_params()

pwact/active_learning/user_input/train_param/train_param.py

@@ -29,23 +29,26 @@ class InputParam(object):
         self.cmd = cmd
         self.inference = True if self.cmd == "test".upper() else False
         self.model_type = get_required_parameter("model_type", json_input).upper()
+        # self.atom_type = get_required_parameter("atom_type", json_input)
         self.atom_type = get_atomic_name_from_str(get_required_parameter("atom_type", json_input))
-
         self.model_num = get_parameter("model_num", json_input, 1)
         self.recover_train = get_parameter("recover_train", json_input, True)
         self.max_neigh_num = get_parameter("max_neigh_num", json_input, 100)
-        
         self.profiling = get_parameter("profiling", json_input, False)#not realized
 
         self.set_feature_params(json_input)
         self.set_workdir_structures(json_input)
+        if self.inference and self.model_type in ["NN", "LINEAR"]:
+            self.file_paths.nn_work = os.path.join(self.file_paths.json_dir, "work_test_dir")
 
         if self.model_type in ["DP", "NN", "NEP", "LINEAR", "CHEBY"]:
             self.set_model_init_params(json_input)
             self.set_default_multi_gpu_info(json_input)
             # set optimizer
             self.set_optimizer(json_input)
-
+            if self.model_type in ["NN", "LINEAR"]:
+                self.optimizer_param.batch_size = 1
+                print("Warning! NN and Linear models only support single batch, automatically adjust batch_size=1.")
         # elif self.model_type in ["NEP"]:
         #     self.set_nep_in_params(json_input)
             
@@ -195,11 +198,8 @@ class InputParam(object):
         # set feature related params
         self.valid_shuffle = get_parameter("valid_shuffle", json_input, False)
         self.data_shuffle = get_parameter("data_shuffle", json_input, True)
-        self.train_valid_ratio = get_parameter("train_valid_ratio", json_input, 0.8)
         self.seed = get_parameter("seed", json_input, 2023)
         self.precision = get_parameter("precision", json_input, "float64")
-        self.chunk_size = get_parameter("chunk_size", json_input, 10)
-        self.format = get_parameter("format", json_input, "pwmat/movement")
 
     '''
     description: 
@@ -211,9 +211,6 @@ class InputParam(object):
     '''
     def set_workdir_structures(self, json_input:dict):
         # set file structures
-        work_dir = get_parameter("work_dir", json_input, None)
-        if work_dir is None:
-            work_dir = os.getcwd()
         self.file_paths = WorkFileStructure(json_dir=os.getcwd(), 
                             reserve_work_dir=get_parameter("reserve_work_dir", json_input, False), 
                             reserve_feature = get_parameter("reserve_feature", json_input, False), 
@@ -233,9 +230,7 @@ class InputParam(object):
         self.recover_train = True
         self.optimizer_param.batch_size = 1     # set batch size to 1, so that each image inference info will be saved
         self.data_shuffle = False
-        self.train_valid_ratio = 1
         self.valid_shuffle = False
-        self.format = get_parameter("format", json_input, "pwmat/movement")
         self.file_paths.set_inference_paths(json_input,is_nep_txt = is_nep_txt)
     
     '''
@@ -267,14 +262,14 @@ class InputParam(object):
     author: wuxingxing
     '''    
     def get_data_file_dict(self):
-        data_file_dict = self.file_paths.get_data_file_structure()
+        data_file_dict = {}
+        # data_file_dict = self.file_paths.get_data_file_structure()
         data_file_dict["M2"] = self.descriptor.M2
         data_file_dict["maxNeighborNum"] = self.max_neigh_num
         data_file_dict["atomType"]=self.atom_type_dict
         data_file_dict["Rc_M"] = self.descriptor.Rmax
         data_file_dict["E_tolerance"] = self.descriptor.E_tolerance
         data_file_dict["train_egroup"] = self.optimizer_param.train_egroup
-        data_file_dict["ratio"] = self.train_valid_ratio
 
         return data_file_dict
     
@@ -282,7 +277,8 @@ class InputParam(object):
         params_dict = {}
         params_dict["model_type"] = self.model_type
         params_dict["atom_type"] = self.atom_type
-        params_dict["max_neigh_num"] = self.max_neigh_num
+        if self.model_type !="NEP":
+            params_dict["max_neigh_num"] = self.max_neigh_num
         if self.seed is not None:
             params_dict["seed"] = self.seed
         if self.model_num > 1 :
@@ -336,6 +332,17 @@ class InputParam(object):
         print(params_dict)
         
 def help_info():
-    print("train: do model training")
-    print("test: do dp model inference")
-    
+    # 使用双线边框和加粗标题
+    print("\n\033[1;36m╔" + "=" * 48 + "╗\033[0m")  # 双线上边框
+    print("\033[1;36m║" + " " * 10 + "\033[1;35m PWMLFF Basic Information \033[0m" + " " * 12 + "\033[1;36m║\033[0m")  # 标题
+    print("\033[1;36m╚" + "=" * 48 + "╝\033[0m")  # 双线下边框
+    print(f"\033[1;32mVersion:\033[0m 2025.02")
+    print(f"\033[1;32mCompatible pwdata:\033[0m >= 0.4.8")
+    print(f"\033[1;32mCompatible pwact:\033[0m >= 0.2.1")
+    print(f"\033[1;32mLast Commit:\033[0m 2025.03.05")
+    print(f"\033[1;32mGit Hash:\033[0m 7bdaa90da15a5bfca6a831e739ebdd67fca22299")
+    print(f"\033[1;32mContact:\033[0m support@pwmat.com")
+    print(f"\033[1;32mCitation:\033[0m https://github.com/LonxunQuantum/PWMLFF")
+    print(f"\033[1;32mManual online:\033[0m http://doc.lonxun.com/PWMLFF/")
+    print("\033[1;36m" + "=" * 50 + "\033[0m")  # 青色分隔线
+    print("\n\n")