Metrics in machine learning of complex systems, algorithm and program code
To solve machine learning problems, a metric is proposed based on the signal-to-noise ratio formula, SNR:
For applications in the field of information technology and measurement technology, where there is a problem of choosing an objective quantitative criterion for the noise immunity of devices, the signal-to-noise ratio, SNR, is used.
The proposed SNR formula is invariant under any linear transformations of sets a(i) (scale and shift invariant) and does not depend on the granulation number M for a set of points of a normal Gaussian distribution. The quadratic forms S and N are positive definite for arbitrary sets a(i).
The formula is derived from the “Cantor dust” fractal. From the derivation of the formula and application experience, it is appropriate to apply it in a complex system, when the ordering of cause-and-effect relationships of elements within a complex system is not significant, but nonlinear tendencies towards self-organization of data are noticeable.
The signal-to-noise ratio is inversely proportional to the number of degrees of freedom of a complex system. The system is characterized by maximum and minimum SNR values and their sequential alternation.
To apply metrics in machine learning, optimization of calculation time is critical. Based on experience, the following software product is proposed.
# SNR, автор Александр Макарик(с)
import numpy as np
from numba import njit
@njit(fastmath=True)
def calcChisl(m):
n=m.size-1
s=0
for i in range (2, n - 1):
s = s + m[i] * (2 * m[i] - m[i + 2] - m[i - 2])
#'s = s + massivOfElements(i] * (massivOfElements2(i] - massivOfElements(i + 2] - massivOfElements(i - 2])
#'для замкнутого контура
s = s + m[0] * (2 * m[0] - m[2] - m[n - 1])
s = s + m[1] * (2 * m[1] - m[3] - m[n])
s = s + m[n - 1] * (2 * m[n - 1] - m[0] - m[n - 3])
s = s + m[n] * (2 * m[n] - m[1] - m[n - 2])
return s
@njit(fastmath=True)
def calcZnam(m):
n=m.size-1
s=0
for i in range (2, n - 1):
s = s + m[i] * (6 * m[i] - 4 * m[i + 1] + m[i + 2] + m[i - 2] - 4 * m[i - 1])
# 's = s + massivOfElements(i] * (massivOfElements6(i] - massivOfElements4(i + 1] + massivOfElements(i + 2] + massivOfElements(i - 2] - massivOfElements4(i - 1])
#'для замкнутого контура
s = s + m[0] * (6 * m[0] - 4 * m[1] + m[2] + m[n - 1] - 4 * m[n])
s = s + m[1] * (6 * m[1] - 4 * m[2] + m[3] + m[n] - 4 * m[0])
s = s + m[n - 1] * (6 * m[n - 1] - 4 * m[n] + m[0] + m[n - 3] - 4 * m[n - 2])
s = s + m[n] * (6 * m[n] - 4 * m[0] + m[1] + m[n - 2] - 4 * m[n - 1])
# 'для незамкнутого контура
# 's = s + m(1] * (3 * m(1] - 4 * m(2] + m(3])
# 's = s + m(2] * (7 * m(2] - 4 * m(1] + -4 * m(3] + m(4])
# 's = s + m(n - 1] * (7 * m(n - 1] - 4 * m(n - 2] - 4 * m(n] + m(n - 3])
# 's = s + m(n] * (3 * m(n] - 4 * m(n - 1] + m(n - 2])
return s
def calcSNR(arr):
#print(arr[0:10])
z=calcZnam(arr)
#if z!=0:
a=calcChisl(arr)/z
#else:
# a=0
if a<0:print ('znam=',znam)
if a<0:print ('Chisl=",znam)
return a
def snrVectorSlow(arr,deslength):
vSNR=np.zeros(arr.size-deslength)
for i in range(arr.size-deslength):
b=arr[i:i+deslength]
# vSNR = np.append(vSNR, SNR.calcSNR(b])
vSNR[i]= calcSNR(b)
return vSNR
@njit(fastmath=True)
def snrChislVector(m):
chisl=np.zeros(m.size)
n=m.size-1
for i in range (2, n - 1):
chisl[i] = m[i] * (2 * m[i] - m[i + 2] - m[i - 2])
#"s = s + massivOfElements(i] * (massivOfElements2(i] - massivOfElements(i + 2] - massivOfElements(i - 2])
#'для замкнутого контура
chisl[0] = m[0] * (2 * m[0] - m[2] - m[n - 1])
chisl[1] = m[1] * (2 * m[1] - m[3] - m[n])
chisl[n-1] = m[n - 1] * (2 * m[n - 1] - m[0] - m[n - 3])
chisl[n] = m[n] * (2 * m[n] - m[1] - m[n - 2])
return chisl
@njit(fastmath=True)
def snrZnamVector(m):
n=m.size-1
k=m
tempV=np.zeros(m.size)
for i in range (2, n - 1):
tempV[i] = k[i] * (6 * k[i] - 4 * k[i + 1] + k[i + 2] + k[i - 2] - 4 * k[i - 1])
tempV[0] = k[0] * (6 * k[0] - 4 * k[1] + k[2] + k[n - 1] - 4 * k[n])
tempV[1] = k[1] * (6 * k[1] - 4 * k[2] + k[3] + k[n] - 4 * k[0])
tempV[n - 1] = k[n - 1] * (6 * k[n - 1] - 4 * k[n] + k[0] + k[n - 3] - 4 * k[n - 2])
tempV[n] = k[n] * (6 * k[n] - 4 * k[0] + k[1] + k[n - 2] - 4 * k[n - 1])
znam=tempV #*9
return znam
@njit(fastmath=True)
def snrVector(arr,deslength):
vSNR=np.zeros(arr.size-deslength)
b=arr[0:deslength]
chisl=snrChislVector(b)
znam=snrZnamVector(b)
vSNR[0]=np.sum(chisl)/np.sum(znam)
n=deslength-1
#d=arr[0:deslength]
for k in range(1,arr.size-deslength):
if (k%1000==0):print(k)
d=arr[k:k+deslength]
#chisl=np.delete(chisl,0)
chisl=chisl[1:chisl.size] #так быстрее
chisl = np.append(chisl, 0) # просто в конец добавляем элемент
chisl[1] = d[1] * (2 * d[1] - d[3] - d[n])
i = n - 2
chisl[i] = d[i] * (2 * d[i] - d[i + 2] - d[i - 2])
chisl[n - 1] = d[n - 1] * (2 * d[n - 1] - d[0] - d[n - 3])
chisl[n] = d[n] * (2 * d[n] - d[1] - d[n - 2])
znam=znam[1:znam.size] #так быстрее
znam = np.append(znam, 0) # просто в конец добавляем элемент
znam[0] = d[0] * (6 * d[0] - 4 * d[1] + d[2] + d[n - 1] - 4 * d[n])
znam[1] = d[1] * (6 * d[1] - 4 * d[2] + d[3] + d[n] - 4 * d[0])
znam[i] = d[i] * (6 * d[i] - 4 * d[i + 1] + d[i + 2] + d[i - 2] - 4 * d[i - 1])
znam[n - 1] = d[n - 1] * (6 * d[n - 1] - 4 * d[n] + d[0] + d[n - 3] - 4 * d[n - 2])
znam[n] = d[n] * (6 * d[n] - 4 * d[0] + d[1] + d[n - 2] - 4 * d[n - 1])
vSNR[k]=np.sum(chisl)/np.sum(znam)
return vSNR
@njit(fastmath=True)
def snrVectorFastest(arr,deslength):
vSNR=np.zeros(arr.size-deslength)
d=arr[0:deslength]
chisl=np.sum(snrChislVector(d))
znam=np.sum(snrZnamVector(d))
kkk=chisl/znam
vSNR[0]=kkk
n=deslength-1
v=np.zeros(6)
# chisl[i] = m[i] * (2 * m[i] - m[i + 2] - m[i - 2])
for k in range(1,arr.size-deslength):
# if (k%1000==0):print(k)
v[0] = d[0] * (2 * d[0] - d[2] - d[n-1])
v[1] = d[1] * (2 * d[1] - d[3] - d[n])
v[2] = d[2] * (2 * d[2] - d[4] - d[0]) #его не обязательно...cчитать потом
i = n - 2
# v[3] = d[i] * (2 * d[i] - d[i + 2] - d[i - 2]) #его удалять не надо...!!! но добавить надо
v[4] = d[n - 1] * (2 * d[n - 1] - d[0] - d[n - 3])
v[5] = d[n] * (2 * d[n] - d[1] - d[n - 2])
chisl=chisl-v[0]-v[1]-v[2]-v[4]-v[5]
#tempV[i] = k[i] * (6 * k[i] - 4 * k[i + 1] + k[i + 2] + k[i - 2] - 4 * k[i - 1])
v[0] = d[0] * (6 * d[0] - 4 * d[1] + d[2] + d[n - 1] - 4 * d[n])
v[1] = d[1] * (6 * d[1] - 4 * d[2] + d[3] + d[n] - 4 * d[0])
v[2] = d[2] * (6 * d[2] - 4 * d[3] + d[4] + d[0] - 4 * d[1]) #его не обязательно считать потом
# v[3] = d[i] * (6 * d[i] - 4 * d[i + 1] + d[i + 2] + d[i - 2] - 4 * d[i - 1]) #его удалять не надо...но добавить надо
v[4] = d[n - 1] * (6 * d[n - 1] - 4 * d[n] + d[0] + d[n - 3] - 4 * d[n - 2])
v[5] = d[n] * (6 * d[n] - 4 * d[0] + d[1] + d[n - 2] - 4 * d[n - 1])
znam=znam-v[0]-v[1]-v[2]-v[4]-v[5]
d=arr[k:k+deslength]
v[0] = d[0] * (2 * d[0] - d[2] - d[n-1])
v[1] = d[1] * (2 * d[1] - d[3] - d[n])
v[3] = d[i] * (2 * d[i] - d[i + 2] - d[i - 2]) #его удалять не надо...!!! но добавить надо
v[4] = d[n - 1] * (2 * d[n - 1] - d[0] - d[n - 3])
v[5] = d[n] * (2 * d[n] - d[1] - d[n - 2])
chisl=chisl+ v[0] + v[1]+v[3]+v[4]+v[5]
v[0] = d[0] * (6 * d[0] - 4 * d[1] + d[2] + d[n - 1] - 4 * d[n])
v[1] = d[1] * (6 * d[1] - 4 * d[2] + d[3] + d[n] - 4 * d[0])
#v[2] = d[2] * (6 * d[2] - 4 * d[3] + d[4] + d[0] - 4 * d[1]) #его не обязательно считать потом
v[3] = d[i] * (6 * d[i] - 4 * d[i + 1] + d[i + 2] + d[i - 2] - 4 * d[i - 1]) #его удалять не надо...но добавить надо
v[4] = d[n - 1] * (6 * d[n - 1] - 4 * d[n] + d[0] + d[n - 3] - 4 * d[n - 2])
v[5] = d[n] * (6 * d[n] - 4 * d[0] + d[1] + d[n - 2] - 4 * d[n - 1])
znam=znam + v[0] + v[1]+v[3]+v[4]+v[5]
vSNR[k]=chisl/znam
return vSNR
