pwact 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

pwact/active_learning/environment.py

@@ -1,4 +1,16 @@
 import subprocess
+import pkg_resources
 def check_envs():
     # for pwmat
-    subprocess.call("module load pwmat", shell=True)
+    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
+
+    # check PWMLFF???

pwact/active_learning/explore/run_model_md.py

@@ -21,7 +21,7 @@ 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
 from pwact.utils.constant import AL_STRUCTURE, TEMP_STRUCTURE, EXPLORE_FILE_STRUCTURE, TRAIN_FILE_STRUCTUR, \
-        FORCEFILED, ENSEMBLE, LAMMPS, LAMMPS_CMD, UNCERTAINTY, DFT_STYLE, SLURM_OUT, SLURM_JOB_TYPE, PWDATA
+        FORCEFILED, ENSEMBLE, LAMMPS, LAMMPS_CMD, UNCERTAINTY, DFT_STYLE, SLURM_OUT, SLURM_JOB_TYPE, PWDATA, MODEL_TYPE
 
 from pwact.utils.format_input_output import get_iter_from_iter_name, get_sub_md_sys_template_name,\
     make_md_sys_name, get_md_sys_template_name, make_temp_press_name, make_temp_name, make_train_name
@@ -247,13 +247,16 @@ class Explore(object):
     def set_forcefiled_file(self, md_dir:str):
         model_name = ""
         md_model_paths = []
-        if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
-            model_name += TRAIN_FILE_STRUCTUR.script_dp_name
-        elif self.input_param.strategy.md_type == FORCEFILED.fortran_lmps:
-            if self.input_param.strategy.compress:
-                raise Exception("ERROR! The compress model does not support fortran lammps md! Please change the 'md_type' to 2!")
-            else:
-                model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.fortran_dp, TRAIN_FILE_STRUCTUR.fortran_dp_name)
+        if self.input_param.train.model_type == MODEL_TYPE.nep:
+            model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.nep_model_lmps)
+        elif self.input_param.train.model_type == MODEL_TYPE.dp:
+            if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
+                model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name)
+            elif self.input_param.strategy.md_type == FORCEFILED.fortran_lmps:
+                if self.input_param.strategy.compress:
+                    raise Exception("ERROR! The compress model does not support fortran lammps md! Please change the 'md_type' to 2!")
+                else:
+                    model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.fortran_dp, TRAIN_FILE_STRUCTUR.fortran_dp_name)
 
         for model_index in range(self.input_param.strategy.model_num):
             model_name_i = "{}/{}".format(make_train_name(model_index), model_name)

pwact/active_learning/slurm.py

@@ -154,31 +154,33 @@ class SlurmJob(object):
     def check_lammps_out_file(self):
         # read last line of md.log file
         md_dirs = self.get_slurm_works_dir()
-        for md_dir in md_dirs:
-            tag_md_file = os.path.join(md_dir, "tag.md.success")
-            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
-
-            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:
-                with open(tag_md_file, 'w') as wf:
-                    wf.writelines("Job Done!")
-                return True
-            else:
-                return False
+        try:
+            for md_dir in md_dirs:
+                tag_md_file = os.path.join(md_dir, "tag.md.success")
+                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
 
-        return True
+                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:
+                    with open(tag_md_file, 'w') as wf:
+                        wf.writelines("Job Done!")
+                    return True
+                else:
+                    return False
+            return True
+        except Exception as e:
+            return False
 
 
 class Mission(object):
@@ -302,7 +304,7 @@ class Mission(object):
         for job in self.job_list:
             if job.status == JobStatus.terminated:
                 if job.submit_num <= JobStatus.submit_limit.value:
-                    print("resubmit job: {}, the time is {}\n".format(job.submit_cmd, job.submit_num))
+                    print("resubmit job {}: {}, the time is {}\n".format(job.jobid, job.submit_cmd, job.submit_num))
                     job.submit()
                 else:
                     job.status = JobStatus.resubmit_failed                    

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
+    TRAIN_INPUT_PARAM, TRAIN_FILE_STRUCTUR, FORCEFILED, LABEL_FILE_STRUCTURE, SLURM_OUT, MODEL_TYPE
 
 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
 '''
@@ -106,18 +106,20 @@ class ModelTrian(object):
         script = ""
         pwmlff = self.resource.train_resource.command
         script += "{} {} {} >> {}\n\n".format(pwmlff, MODEL_CMD.train, TRAIN_FILE_STRUCTUR.train_json, SLURM_OUT.train_out)
-        if self.input_param.strategy.compress:
-            script += "    {} {} {} -d {} -o {} -s {} >> {}\n\n".format(pwmlff, MODEL_CMD.compress, model_path, \
-                self.input_param.strategy.compress_dx, self.input_param.strategy.compress_order, TRAIN_FILE_STRUCTUR.compree_dp_name, SLURM_OUT.train_out)
-            cmp_model_path = "{}".format(TRAIN_FILE_STRUCTUR.compree_dp_name)
+
+        # do nothing for nep model
+        if self.input_param.train.model_type == MODEL_TYPE.dp:
+            if self.input_param.strategy.compress:
+                script += "    {} {} {} -d {} -o {} -s {}/{} >> {}\n\n".format(pwmlff, MODEL_CMD.compress, model_path, \
+                    self.input_param.strategy.compress_dx, self.input_param.strategy.compress_order, TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.compree_dp_name, SLURM_OUT.train_out)
+                cmp_model_path = "{}/{}".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.compree_dp_name)
             
-        if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
-            if cmp_model_path is None:
-                # script model_record/dp_model.ckpt the torch_script_module.pt will in model_record dir
-                script += "    {} {} {} >> {}\n".format(pwmlff, MODEL_CMD.script, model_path, SLURM_OUT.train_out)
-                script += "    mv ./{}/{} .\n\n".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name)
-            else:
-                script += "    {} {} {} >> {}\n\n".format(pwmlff, MODEL_CMD.script, cmp_model_path, SLURM_OUT.train_out)
+            if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
+                if cmp_model_path is None:
+                    # script model_record/dp_model.ckpt the torch_script_module.pt will in model_record dir
+                    script += "    {} {} {} {}/{} >> {}\n".format(pwmlff, MODEL_CMD.script, model_path, TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name, SLURM_OUT.train_out)
+                else:
+                    script += "    {} {} {} {}/{} >> {}\n\n".format(pwmlff, MODEL_CMD.script, cmp_model_path, TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name, SLURM_OUT.train_out)
         return script
 
     '''

pwact/active_learning/user_input/iter_input.py

@@ -3,7 +3,7 @@ import glob
 
 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 TrainParam
+from pwact.active_learning.user_input.train_param.train_param import InputParam as TrainParam
 from pwact.active_learning.user_input.scf_param import SCFParam
 class InputParam(object):
     # _instance = None
@@ -12,7 +12,8 @@ class InputParam(object):
         if not os.path.isabs(self.root_dir):
             self.root_dir = os.path.realpath(self.root_dir)
         self.record_file = get_parameter("record_file", json_dict, "al.record")
-        print("Warning! record_file not provided, automatically set to {}! ".format(self.record_file))
+        if "record_file" not in json_dict.keys():
+            print("Warning! record_file not provided, automatically set to {}! ".format(self.record_file))
         
         self.reserve_work = get_parameter("reserve_work", json_dict, False)
         # self.reserve_feature = get_parameter("reserve_feature", json_dict, False)

pwact/active_learning/user_input/resource.py

@@ -69,7 +69,10 @@ class Resource(object):
         env_script = ""
         if len(source_list) > 0:
             for source in source_list:
-                if "source" != source.split()[0].lower():
+                if "source" != source.split()[0].lower() and \
+                    "export" != source.split()[0].lower() and \
+                        "module" != source.split()[0].lower() and \
+                            "conda" != source.split()[0].lower():
                     tmp_source = "source {}\n".format(source)
                 else:
                     tmp_source = "{}\n".format(source)

pwact/active_learning/user_input/scf_param.py

@@ -165,7 +165,7 @@ class DFTInput(object):
 
             if "MP_N123" in key_values and self.kspacing is not None:
                 error_info = "ERROR! The 'kspacing' in DFT/input/{} dict and 'MP_N123' in {} file cannot coexist.\n".format(os.path.basename(self.input_file), os.path.basename(self.input_file))
-                error_info += "If 'MP_N123' is not indicated in DFT/input/{}, we will use 'kspacing' param to generate the 'MP_N123' parameter\n".format(os.path.basename(self.input_file))
+                error_info += "If 'MP_N123' is not indicated in DFT/input/{}, the 'kspacing' param will be used to generate the 'MP_N123' parameter\n".format(os.path.basename(self.input_file))
                 raise Exception(error_info)
             elif "MP_N123" not in key_values and self.kspacing is None:
                 self.kspacing  = 0.5

pwact/active_learning/user_input/train_param/model_param.py

@@ -31,7 +31,8 @@ class NetParam(object):
         if "type_" in self.net_type:
             dicts["physical_property"] = self.physical_property
         #dicts["bias"] = self.bias, 
-        #dicts["resnet_dt"] = self. resnet_dt, 
+        # if self.resnet_dt is False:
+        #     dicts["resnet_dt"] = self.resnet_dt
         #dicts["activation"] = self.activation
         return dicts
 
@@ -40,6 +41,7 @@ class ModelParam(object):
         self.type_embedding_net = None
         self.embedding_net = None
         self.fitting_net = None
+        self.nep_param:NetParam = None
 
     '''
     description: 
@@ -75,7 +77,9 @@ class ModelParam(object):
     def set_nn_fitting_net(self, fitting_net_dict:dict):
         # fitting_net_dict = get_parameter("fitting_net",json_input, {})
         network_size = get_parameter("network_size", fitting_net_dict,[15,15,1])
-        if network_size[-1] != 1:
+        if not isinstance(network_size, list):
+            network_size = [network_size]
+        if len(network_size) > 1 and network_size[-1] != 1:
             raise Exception("Error: The last layer of the fitting network should have a size of 1 for etot energy, but the input size is {}!".format(network_size[-1]))
         bias = True # get_parameter("bias", fitting_net_dict, True)
         resnet_dt = False # get_parameter("resnet_dt", fitting_net_dict, False)
@@ -91,4 +95,3 @@ class ModelParam(object):
     #     #     dicts[self.fitting_net.net_type] = self.fitting_net.to_dict()
     #     return self.fitting_net.to_dict_std()
 
-