memristor

Memristor.py

@@ -0,0 +1,188 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn import preprocessing
+
+
+class memristor_models():
+    def __init__(self,Roff,Ron,Rint,Amplitude,freq,time_duration,sample_rate,p,j,model):
+        self.initial_Roff=Roff
+        self.initial_Ron=Ron
+        self.Rint=Rint
+        self.Amplitude=Amplitude
+        self.freq=freq
+        self.time_duration=time_duration
+        self.time_duration=time_duration
+        self.sample_rate=sample_rate
+        self.p=p
+        self.j=j
+        self.model= model
+    
+    # window functions
+    def jog(self,x1,p):
+        f_x = 1-(((2*x1)-1)**(2*p))
+        return f_x
+
+    def Prodro(self,x1,p,j):
+        f_x = j*(1-(((x1-0.5)**2)+0.75**p))
+        return f_x
+        
+    def biolek(self,x1,p,i):
+        if i<0:
+            i=0
+        else:
+            i=1
+        f_x=1-((x1-i)**p)
+        return f_x
+    
+    def zha(self,x1,p,j,i):
+        if i<0:
+            i=0
+        else:
+            i=1
+        f_x=j*((1-(0.25*(x1-i)**2)+0.75)**p)
+        return f_x
+    
+    def ideal_model(self):
+        start_time = 0
+        time = np.arange(start_time, self.time_duration, 1/self.sample_rate)
+        sinewave = self.Amplitude * np.sin(2 * np.pi * self.freq * time + 0)
+        v_mem=sinewave
+        D=10*pow(10,-9)
+        uv=10*pow(10,-15)
+        delta_R=self.initial_Roff-self.initial_Ron
+        x=(self.initial_Roff-self.Rint)/delta_R
+        x_t=[]
+        i_mem=[]
+        x_t.append(x)
+        R_mem=[]
+        G=[]
+        f1=[]
+        r_val=(self.initial_Ron*x_t[0])+(self.initial_Roff*(1-x_t[0]))
+        R_mem.append(r_val)
+        k=(uv*self.initial_Ron)/(D**2)
+        i_mem.append(0)
+        for i in range(1,len(v_mem)):
+            i_val=v_mem[i]/R_mem[i-1]
+            i_mem.append(i_val)
+
+            if self.model=='Joglekar':
+                f=self.jog(x_t[i-1],self.p)
+                f1.append(f)
+            if self.model== 'Prodromakis':
+                f=self.Prodro(x_t[i-1],self.p,self.j)
+                f1.append(f)
+            if self.model== 'Biolek':
+                f=self.biolek(x_t[i-1],self.p,i_val)
+                f1.append(f)
+            if self.model== 'Zha':
+                f=self.zha(x_t[i-1],self.p,self.j,i_val)
+                f1.append(f)
+            dx_dt=k*i_mem[i-1]*f
+            dx=dx_dt*(time[i-1]-time[i])
+            x=dx+x_t[i-1]
+            x_t.append(x)
+            r_temp=(self.initial_Ron*x)+(self.initial_Roff*(1-x))
+            if r_temp<self.initial_Ron:
+                r_temp=self.initial_Ron
+            if r_temp>self.initial_Roff:
+                r_temp=self.initial_Roff
+            R_mem.append(r_temp)
+            G.append(1/r_temp)
+            
+        self.Roff=max(R_mem)
+        self.Ron=min(R_mem)
+    
+        return v_mem,i_mem,G,x_t,time,f1
+
+    def plot(self):
+        v,curr,G,x,t,f=self.ideal_model()
+        plt.plot(v,curr)
+        plt.ylabel('i')
+        plt.xlabel('v')
+        plt.show()
+        
+    def neural_weight(self,neural_weight,X_max,X_min):
+        self.neural_weight=np.array(neural_weight)
+
+        new_min = (1/self.Roff) 
+        new_max = (1/self.Ron)
+
+        # new_weights = []
+        self.mapped_values = []
+        idx = 0
+        for item in self.neural_weight:
+            self.mapped_values.append([])
+            for x in item:
+                scaled_x = ((np.abs(x) - X_min) / (X_max - X_min)) * (new_max - new_min) + new_min
+                if x<0:
+                    scaled_x = scaled_x*-1
+                self.mapped_values[idx].append(scaled_x)
+            idx += 1
+            
+        # Iterate over the old weights and biases and compute the new values
+        # for weight in neural_weight:
+        #     new_weight = ((abs(weight) - X_min) / (X_max - X_min)) * (new_max - new_min) + new_min
+        #     new_weight = [(new_weight[i] * -1) if weight[i]<0 else new_weight[i] for i in range(len(new_weight)) ]
+        #     new_weights.append(new_weight)
+
+        # self.mapped_values = new_weights  
+
+    def variability(self,partition,variability_percentage_Ron,variability_percentage_Roff):
+        v,curr,G,x,t,f = self.ideal_model()
+        self.partition = partition
+        self.variability_percentage_Ron = variability_percentage_Ron  
+        self.variability_percentage_Roff = variability_percentage_Roff
+
+        # partitioning
+        self.l2 = []
+        self.l2.append(1/self.Roff)
+        step = ((1/self.Ron)-(1/self.Roff))/(self.partition-1)
+        for i in range(1,self.partition):
+            (self.l2).append(self.l2[0]+(step*i))
+
+        # adding variability to the list
+        new_Goff = (1/self.Roff)+(((1/self.Roff)*self.variability_percentage_Roff)/100)
+        (self.l2).append(new_Goff)
+        
+        new_Gon = (1/self.Ron)+(((1/self.Ron)*self.variability_percentage_Ron)/100)
+        (self.l2).append(new_Gon)
+        
+        temp = [val for val in self.l2 if (val<=new_Gon and val>=new_Goff)]
+        self.l2 = temp
+                
+        self.l2.sort()
+      
+    def new_weights(self):
+        self.new_values = []
+        idx = 0
+
+        def closest(lst, K):
+            return lst[min(range(len(lst)), key = lambda i: abs(lst[i]-K))]
+
+        for values in self.mapped_values:
+            self.new_values.append([])
+            for value in values:
+                close_val = closest(self.l2,abs(value))
+                if value <0:
+                    close_val = close_val*-1000
+                else:
+                    close_val = close_val*1000
+                self.new_values[idx].append(close_val)
+            idx += 1
+
+        return self.new_values
+
+    def Relative_Error (self):
+      Weights_with_var= self.new_weights()
+      self.variability(self.partition,0,0)
+      Weights_without_var= self.new_weights()
+      
+      error=[]
+      for i, j in zip(np.array(Weights_without_var), np.array(Weights_with_var)):
+          l = (np.abs(i-j)/i)
+          error.append(l)
+
+      error  = np.array(error) 
+      return np.abs(np.sum(error))*100/error.size
+