fork download
copy 
  1. # your code gimport random
  2. import sys
  3. import numpy
  4. import math
  5.  
  6. eta=0.0001 #learning rate
  7. n=200 #number of training epoch
  8. inp=30 #input layer size
  9. m=60 #hidden layer size
  10. y=0 #output signal
  11. t=0 #target signal
  12. e=0 #error
  13. d_y=0 #local gradient for the last neuron
  14. err=0 #calculated network error for output neuron
  15. err_av=0 #average network error
  16. path='dataTrain.txt' #training sample
  17. path2='dataLaunch.txt' #launching a forecast
  18. day = 365 #number of days of forecasting
  19.  
  20. x=[] #training sample
  21. w=[[0 for j in range(inp)] for i in range(m)] #matrix of weights (synapses)
  22. v=[0 for j in range(m)] #vector of weights of the output layer
  23. y_s=[0 for j in range(m)] #hidden layer of neurons
  24. d_y_s=[0 for j in range(m)] #local gradients for hidden layer neurons
  25. averError=[] #array of NS errors (by epoch)
  26. window=[] #sliding window
  27. predict=[]
  28. fact=[] #target values
  29. training=[] #values obtained by the INS during training
  30. y_s2=[0 for j in range(m)]
  31. a=-1
  32. b=1
  33.  
  34. def sigmoid(arg):
  35.   res = 1.0/(1+numpy.exp(-(arg-1)))
  36.   return res
  37.  
  38. def tanh(arg):
  39.     return (numpy.exp(arg) - numpy.exp(-arg)) / (numpy.exp(arg) + numpy.exp(-arg))
  40.  
  41. def tanh_der(arg):
  42.     return 1 - numpy.power(tanh(arg), 2)
  43.  
  44. def ReLu(arg):
  45.     return max(0.00001*arg, arg)
  46.  
  47. def ReLu_der(arg):
  48.     return 1 if arg > 0 else 0.00001
  49.  
  50. def init_x(path):
  51.     t=0 #auxiliary variable
  52.  
  53.     for i in range(0, m):
  54.       for j in range(0, inp):
  55.           w[i][j]=random.random()*(1+1)-1
  56.  
  57.     for j in range(0, m):
  58.         v[j]=random.random()*(1+1)-1
  59.  
  60.     try:
  61.        f=open(path,'r')
  62.     except FileNotFoundError:
  63.        print("File not found")
  64.        sys.exit()
  65.  
  66.     for k in f:
  67.         x.append([])
  68.         x[t].extend([float(x) for x in k.split()])
  69.         t=t+1
  70.  
  71.     f.close()
  72.  
  73.     for i in range(0, len(x)):
  74.      fact.append(x[i][30])
  75.      xmax=max(x[i])
  76.      xmin=min(x[i])
  77.      for j in range(0, len(x[i])):
  78.       x[i][j]=a+(x[i][j]-xmin)/(xmax-xmin)*(b-a)
  79.      x[i].insert(0, xmax) 
  80.      x[i].insert(0, xmin)
  81.     random.shuffle(x)
  82.  
  83. def train(): 
  84.   for k in range(1, n+1): #cycle by epoch
  85.     err_av=0
  86.     for f in range(0, len(x)): #cycle by samples
  87.       for i in range(0, m):
  88.         sum=0
  89.         for j in range(0, inp):
  90.            sum=sum+w[i][j]*x[f][j+2] #weighted sum of inputs
  91.         y_s[i]=sum
  92.       for p in range(0, m):
  93.         y_s[p]=sigmoid(y_s[p]) #The activation signal is converted using the activation function
  94.       #calculating output neuron activity
  95.       sum2=0
  96.       for z in range(0, m):
  97.         sum2=sum2+v[z]*y_s[z]
  98.       y=sigmoid(sum2) #end of propagation. y - output
  99.  
  100.       t=x[f][32] #target value
  101.       e=y-t
  102.       err=pow(e, 2)/2
  103.       err_av=err_av+err
  104.  
  105.       if k == n:
  106.         training.append(((y-a)/(b-a))*(x[f][1]-x[f][0])+x[f][0])
  107.  
  108.       d_y=e*y*(1-y)
  109.       #modification of the output layer weights
  110.       for q in range(0, m):
  111.         v[q]=v[q]-eta*d_y*y_s[q]
  112.       for r in range(0, m):
  113.         d_y_s[r]=d_y*v[r] 
  114.  
  115.       for i1 in range(0, m):
  116.         for j1 in range(0, inp):
  117.           w[i1][j1]=w[i1][j1]-eta*d_y_s[i1]*y_s[i1]*(1-y_s[i1])*x[f][j1+2]
  118.     averError.append(math.sqrt(err_av/n/(f+1)))
  119.  
  120. def prediction(window, predict, day):
  121.   predict.extend(window)
  122.  
  123.   for z in range(1, day+1):
  124.    xmax=max(window)
  125.    xmin=min(window)
  126.    for t in range(0, len(window)):
  127.      window[t]=a+((window[t]-xmin)/(xmax-xmin))*(b-a)
  128.  
  129.    for i in range(0, m):
  130.       sum=0
  131.       for j in range(0, inp):
  132.         sum=sum+w[i][j]*window[j]
  133.       y_s2[i]=sum
  134.   #calculating the activity of hidden layer neurons
  135.    for i in range(0, m):
  136.     y_s2[i]=sigmoid(y_s2[i])
  137.   #calculating output neuron activity
  138.    sum=0
  139.    for j in range(0, m):
  140.      sum=sum+v[j]*y_s2[j]
  141.    t=sigmoid(sum)
  142.  
  143.    window.append(t)
  144.    window.pop(0)
  145.    predict.append(round(((t-a)/(b-a))*(xmax-xmin)+xmin, 2)) #denormalization of the output
  146.    for i in range(0, len(window)):
  147.        window[i]=((window[i]-a)/(b-a))*(xmax-xmin)+xmin #denormalization of the entire sliding window   
  148.  
  149. try:
  150.     f=open(path2,'r')
  151. except FileNotFoundError:
  152.     print("File not found")
  153.     sys.exit()
  154.  
  155. entrance=f.readline()
  156. window.extend([float(x) for x in entrance.split()])
  157. data=f.readline()
  158. data=data.strip()
  159. f.close()
  160.  
  161. init_x(path)
  162. train()
  163. prediction(window, predict, day)
Success #stdin #stdout 0.29s 27100KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
File not found
https://ideone.com/vV2QW6
language:
Python 3 (python  3.12)
created:
3 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!