MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/ModelHessian/tshess.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+class TransitionStateHessian:
+    """
+    A class for modifying an existing Hessian matrix to introduce a negative eigenvalue 
+    for transition state optimizations, but without using neg_eigenvalue directly as the replacement.
+    Instead, it applies a procedure to the targeted eigenvalue: first take its absolute value,
+    multiply by -1, and then add neg_eigenvalue.
+    """
+
+    def __init__(self):
+        pass
+
+    def create_ts_hessian(self, model_hessian, cart_gradient):
+        
+        # Diagonalize the supplied Hessian
+        eigenvalues, eigenvectors = np.linalg.eigh(model_hessian)
+     
+        if np.any(eigenvalues < -1e-8):
+            return model_hessian  # No need to modify if negative eigenvalues already exist
+        
+                
+        count = 0
+        for i in range(len(eigenvalues)):
+            if abs(eigenvalues[i]) < 1e-8:
+                count += 1
+            else:
+                break
+   
+        
+        target_eigvec = eigenvectors[:, count]
+   
+        P = np.eye(len(eigenvalues)) - 2.0 * np.outer(target_eigvec, target_eigvec) 
+
+        ts_hessian = np.dot(P, model_hessian)
+
+        # Enforce symmetry
+        ts_hessian = 0.5 * (ts_hessian + ts_hessian.T)
+
+        return ts_hessian

multioptpy/Optimizer/QHAdam.py

@@ -0,0 +1,61 @@
+import numpy as np
+import copy
+    
+class QHAdam:
+    def __init__(self, **config):
+        #arXiv:1810.06801v4    
+        self.adam_count = 1
+        self.DELTA = 0.1
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.Epsilon = 1e-12
+        self.nu_m = 1.0
+        self.nu_v = 1.0
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+   
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("QHAdam")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.Initialization = False
+        
+        adam_count = self.adam_count
+        adam_m = self.adam_m
+        adam_v = self.adam_v
+        new_adam_m = adam_m*0.0
+        new_adam_v = adam_v*0.0
+        
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.beta_m*adam_m[i] + (1.0-self.beta_m)*(B_g[i]))
+            new_adam_v[i] = copy.copy(self.beta_v*adam_v[i] + (1.0-self.beta_v)*(B_g[i])**2)
+    
+                    
+        move_vector = []
+
+        for i in range(len(geom_num_list)):
+            move_vector.append(self.DELTA*((1.0 - self.nu_m) * B_g[i] + new_adam_m[i] * self.nu_m)/np.sqrt(((1.0 - self.nu_v) * B_g[i] ** 2 + new_adam_v[i] * self.nu_v)+self.Epsilon))
+                
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        
+        return move_vector#Bohr
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return 
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/abc_fire.py

@@ -0,0 +1,83 @@
+import numpy as np
+import copy
+
+
+ 
+class ABC_FIRE:
+    def __init__(self, **config):#MD-like optimization method. 
+        #ABC_FIRE
+        #Computational Materials Science Volume 218, 5 February 2023, 111978
+        self.iter = 0
+        self.sub_iter = 0
+        self.N_acc = 5
+        self.f_inc = 1.10
+        self.f_acc = 0.99
+        self.f_dec = 0.50
+        self.dt_max = 0.8
+        self.alpha_start = 0.1
+        
+        self.display_flag = True
+        self.config = config
+        self.Initialization = True
+        self.hessian = None
+        self.bias_hessian = None
+   
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        
+        
+
+        if self.Initialization:
+            self.dt = 0.1
+            self.alpha = self.alpha_start
+            self.n_reset = 0
+            self.pre_velocity = geom_num_list * 0.0
+            self.Initialization = False
+            
+        
+        
+        velocity = (1.0 / (1.0 - (1.0 - self.alpha) ** (self.sub_iter) + 1e-10)) * (1.0 - self.alpha) * self.pre_velocity + self.alpha * (np.linalg.norm(self.pre_velocity, ord=2)/np.linalg.norm(B_g, ord=2)) * B_g
+        
+        if self.iter > 0 and np.dot(self.pre_velocity.reshape(1, len(geom_num_list)), B_g.reshape(len(geom_num_list), 1)) > 0:
+            if self.n_reset > self.N_acc:
+                self.dt = min(self.dt * self.f_inc, self.dt_max)
+                self.alpha = self.alpha * self.f_acc
+            self.n_reset += 1
+        else:
+           
+            velocity *= 0.0
+            self.alpha = self.alpha_start
+            self.dt *= self.f_dec
+            self.n_reset = 0
+        
+        velocity += self.dt*B_g
+        
+        move_vector = copy.copy(self.dt * velocity)
+        
+        if self.display_flag:
+            print("FIRE")
+            print("dt, alpha, n_reset :", self.dt, self.alpha, self.n_reset)
+        
+        self.pre_velocity = velocity
+        self.iter += 1
+        self.sub_iter += 1
+        if self.iter > 0:
+            if np.dot(velocity.reshape(1, len(geom_num_list)), B_g.reshape(len(geom_num_list), 1)) < 0:
+                self.sub_iter = 0
+        return move_vector#Bohr.
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/adabelief.py

@@ -0,0 +1,58 @@
+import numpy as np
+import copy
+
+class Adabelief:
+    def __init__(self, **config):
+        #AdaBelief
+        #ref. arXiv:2010.07468v5
+        self.adam_count = 1
+        self.DELTA = 0.03
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.Epsilon = 1e-15
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("AdaBelief")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.Initialization = False
+        
+        adam_count = self.adam_count
+        adam_m = self.adam_m
+        adam_v = self.adam_v
+        new_adam_m = adam_m*0.0
+        new_adam_v = adam_v*0.0
+        
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.beta_m*adam_m[i] + (1.0-self.beta_m)*(B_g[i]))
+            new_adam_v[i] = copy.copy(self.beta_v*adam_v[i] + (1.0-self.beta_v)*(B_g[i]-new_adam_m[i])**2)
+            
+        move_vector = []
+
+        for i in range(len(geom_num_list)):
+            move_vector.append(self.DELTA*new_adam_m[i]/np.sqrt(new_adam_v[i]+self.Epsilon))
+        
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        
+        return move_vector#Bohr
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/adabound.py

@@ -0,0 +1,68 @@
+import numpy as np
+import copy
+
+
+
+   
+class AdaBound:
+    def __init__(self, **config):
+        #AdaBound
+        #arXiv:1902.09843v1
+        self.adam_count = 1
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.DELTA = 0.05
+        self.Epsilon = 1e-08
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("AdaBound")
+        
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = np.zeros((len(geom_num_list), 3, 3))
+            
+            self.Initialization = False
+        
+        move_vector = []
+ 
+            
+        new_adam_m = self.adam_m*0.0
+        new_adam_v = self.adam_v*0.0
+        V = self.adam_m*0.0
+        Eta = self.adam_m*0.0
+        Eta_hat = self.adam_m*0.0
+        
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.beta_m*self.adam_m[i] + (1.0-self.beta_m)*(B_g[i]))
+            new_adam_v[i] = copy.copy(self.beta_v*self.adam_v[i] + (1.0-self.beta_v)*(np.dot(np.array([B_g[i]]).T, np.array([B_g[i]]))))
+            V[i] = copy.copy(np.diag(new_adam_v[i]))
+            
+            Eta_hat[i] = copy.copy(np.clip(self.DELTA/(np.sqrt(V[i]) + self.Epsilon), 0.1 - (0.1/((1.0 - self.beta_v) ** (self.adam_count + 1) + self.Epsilon)) ,0.1 + 0.1/((1.0 - self.beta_v) ** self.adam_count + self.Epsilon) ))
+            Eta[i] = copy.copy(Eta_hat[i]/np.sqrt(self.adam_count))
+                
+        for i in range(len(geom_num_list)):
+            move_vector.append(Eta[i] * new_adam_m[i])
+            
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        return move_vector    
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/adadelta.py

@@ -0,0 +1,65 @@
+import numpy as np
+import copy
+
+
+class Adadelta:
+    def __init__(self, **config):
+        #Adadelta
+        #arXiv:1212.5701v1
+        self.adam_count = 1
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.DELTA = 0.03
+        self.Epsilon = 1e-06
+        self.RMS_DISPLACEMENT_THRESHOLD = 0.0
+        self.RMS_FORCE_THRESHOLD = 1e+10
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):#delta is not required. This method tends to converge local minima. This class doesnt work well.
+        print("Adadelta")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            
+            self.Initialization = False
+        rho = 0.9
+        new_adam_m = self.adam_m*0.0
+        new_adam_v = self.adam_v*0.0
+
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(rho * self.adam_m[i] + (1.0 - rho)*(B_g[i]) ** 2)
+        move_vector = []
+        
+        for i in range(len(geom_num_list)):
+            if self.adam_count > 1:
+                move_vector.append(B_g[i] * (np.sqrt(np.square(self.adam_v).mean()) + self.Epsilon)/(np.sqrt(np.square(new_adam_m).mean()) + self.Epsilon))
+            else:
+                move_vector.append(B_g[i])
+        if abs(np.sqrt(np.square(move_vector).mean())) < self.RMS_DISPLACEMENT_THRESHOLD and abs(np.sqrt(np.square(B_g).mean())) > self.RMS_FORCE_THRESHOLD:
+            move_vector = B_g
+
+        for i in range(len(geom_num_list)):
+            new_adam_v[i] = copy.copy(rho * self.adam_v[i] + (1.0 - rho) * (move_vector[i]) ** 2)
+                
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        return move_vector
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/adaderivative.py

@@ -0,0 +1,56 @@
+import numpy as np
+import copy
+    
+class Adaderivative:
+    def __init__(self, **config):
+        #Engineering Applications of Artificial Intelligence 2023, 119, 105755. https://doi.org/10.1016/j.engappai.2022.105755
+        self.adam_count = 1
+        self.DELTA = 0.0001
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.Epsilon = 1e-12
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g, pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("Adaderivative")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.Initialization = False
+        
+        adam_count = self.adam_count
+        adam_m = self.adam_m
+        adam_v = self.adam_v
+        new_adam_m = adam_m*0.0
+        new_adam_v = adam_v*0.0
+        
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy((self.beta_m * adam_m[i] + (1.0-self.beta_m) * (B_g[i]) ))
+            new_adam_v[i] = copy.copy((self.beta_v * adam_v[i] + (1.0-self.beta_v) * (B_g[i] - pre_B_g[i]) ** 2))
+            
+        move_vector = []
+
+        for i in range(len(geom_num_list)):
+            move_vector.append(self.DELTA*new_adam_m[i]/np.sqrt(new_adam_v[i]+self.Epsilon))
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+
+        return move_vector#Bohr
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/adadiff.py

@@ -0,0 +1,68 @@
+import numpy as np
+import copy
+
+
+
+    
+class AdaDiff:
+    def __init__(self, **config):
+        #AdaDiff
+        #ref. https://iopscience.iop.org/article/10.1088/1742-6596/2010/1/012027/pdf  Dian Huang et al 2021 J. Phys.: Conf. Ser. 2010 012027
+        self.adam_count = 1
+        self.DELTA = 0.03
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.Epsilon = 1e-12
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g, pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("AdaDiff")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.Initialization = False
+         
+        adam_count = self.adam_count
+        adam_m = self.adam_m
+        adam_v = self.adam_v
+        new_adam_m = adam_m*0.0
+        new_adam_v = adam_v*0.0
+        new_adam_m_hat = adam_m*0.0
+        new_adam_v_hat = adam_v*0.0
+        
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.beta_m*adam_m[i] + (1.0-self.beta_m)*(B_g[i]))
+            new_adam_v[i] = copy.copy(self.beta_v*adam_v[i] + (1.0-self.beta_v)*(B_g[i])**2 + (1.0-self.beta_v) * (B_g[i] - pre_B_g[i]) ** 2)
+    
+                    
+        move_vector = []
+        for i in range(len(geom_num_list)):
+            new_adam_m_hat[i] = copy.copy(new_adam_m[i]/(1 - self.beta_m**adam_count))
+            new_adam_v_hat[i] = copy.copy((new_adam_v[i] + self.Epsilon)/(1 - self.beta_v**adam_count))
+        
+        
+        for i in range(len(geom_num_list)):
+                move_vector.append(self.DELTA*new_adam_m_hat[i]/np.sqrt(new_adam_v_hat[i]+self.Epsilon))
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        
+        return move_vector#Bohr.
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return     
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/adafactor.py

@@ -0,0 +1,70 @@
+import numpy as np
+import copy
+
+
+
+class Adafactor:
+    def __init__(self, **config):
+        #Adafactor
+        #arXiv:1804.04235v1
+        self.adam_count = 1
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.DELTA = 0.06
+        self.Epsilon_1 = 1e-08
+        self.Epsilon_2 = self.DELTA
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("Adafactor")
+        
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.adam_u = geom_num_list * 0.0
+            
+            self.Initialization = False
+
+        beta = 1 - self.adam_count ** (-0.8)
+        rho = min(0.01, 1/np.sqrt(self.adam_count))
+        alpha = max(np.sqrt(np.square(geom_num_list).mean()),  self.Epsilon_2) * rho
+        new_adam_m = self.adam_m
+        new_adam_v = self.adam_v*0.0
+        new_adam_u = self.adam_u*0.0
+        new_adam_u_hat = self.adam_u*0.0
+        for i in range(len(geom_num_list)):
+            new_adam_v[i] = copy.copy(beta*self.adam_v[i] + (1.0-beta)*((B_g[i])**2 + np.array([1]) * self.Epsilon_1))
+            new_adam_u[i] = copy.copy(B_g[i]/np.sqrt(new_adam_v[i]))
+            
+                    
+        move_vector = []
+        for i in range(len(geom_num_list)):
+            new_adam_u_hat[i] = copy.copy(new_adam_u[i] / max(1, np.sqrt(np.square(new_adam_u).mean())))
+        
+        
+        for i in range(len(geom_num_list)):
+            move_vector.append(alpha*new_adam_u_hat[i])
+                
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_u = new_adam_u
+        self.adam_count += 1
+        
+        return move_vector
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/adam.py

@@ -0,0 +1,65 @@
+import numpy as np
+import copy
+
+
+
+class Adam:
+    def __init__(self, **config):
+        #Adam
+        #arXiv:1412.6980
+        self.adam_count = 1
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.DELTA = 0.03
+        self.Epsilon = 1e-08
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+        
+        
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("Adam")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            
+            self.Initialization = False
+            
+        new_adam_m = self.adam_m*0.0
+        new_adam_v = self.adam_v*0.0
+        
+        new_adam_m_hat = self.adam_m*0.0
+        new_adam_v_hat = self.adam_v*0.0
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.beta_m*self.adam_m[i] + (1.0-self.beta_m)*(B_g[i]))
+            new_adam_v[i] = copy.copy(self.beta_v*self.adam_v[i] + (1.0-self.beta_v)*(B_g[i])**2)
+    
+                    
+        move_vector = []
+        for i in range(len(geom_num_list)):
+            new_adam_m_hat[i] = copy.copy(new_adam_m[i]/(1 - self.beta_m**self.adam_count))
+            new_adam_v_hat[i] = copy.copy((new_adam_v[i] + self.Epsilon)/(1 - self.beta_v**self.adam_count))
+        
+        
+        for i in range(len(geom_num_list)):
+                move_vector.append(self.DELTA*new_adam_m_hat[i]/np.sqrt(new_adam_v_hat[i]+self.Epsilon))
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        
+        return move_vector#Bohr.
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian