def stepper(self, data, s, target=None, beta=0, return_derivatives=False): dsdt = [] dsdt.append(-s[0] + torch.mul(rhop(s[0]), self.w[1](rho(s[1])) + self.w[2](rho(data)))) if beta > 0: dsdt[0] = dsdt[0] + beta * (target - s[0]) dsdt.append(-s[1] + torch.mul( rhop(s[1]), self.w[4](rho(data)) + torch.mm(rho(s[0]), self.w[1].weight))) for i in range(self.ns): s[i] = s[i] + self.dt * dsdt[i] if not self.no_clamp: for i in range(self.ns): s[i] = s[i].clamp(min=0).clamp(max=1) dsdt[i] = torch.where((s[i] == 0) | (s[i] == 1), torch.zeros_like(dsdt[i], device=self.device), dsdt[i]) if return_derivatives: return s, dsdt else: return s
def stepper(self, data, s, target=None, beta=0, return_derivatives=False): dsdt = [] dsdt.append(-s[0] + rho(self.w[0](s[1]))) if beta > 0: dsdt[0] = dsdt[0] + beta * (target - s[0]) for i in range(1, self.ns - 1): dsdt.append(-s[i] + rho(self.w[2 * i](s[i + 1]) + torch.mm(s[i - 1], self.w[2 * (i - 1)].weight))) dsdt.append(-s[-1] + rho(self.w[-1](data) + torch.mm(s[-2], self.w[-3].weight))) for i in range(self.ns): s[i] = s[i] + self.dt * dsdt[i] if return_derivatives: return s, dsdt else: return s
from chi_diff import applyrho from kernel import getBitposAfterOneRhoPi as lol from kernel import getOneBitPos import main # line = input().split(" ") # w = 64 # print(lol(int(line[0]), int(line[1]), w)) w = 64 for x in range(5): for y in range(5): for z in range(w): o1 = applyrho(x, y, z) A = [[[0 for k in range(w)] for j in range(5)] for i in range(5)] A[x][y][z] = 1 A = main.rho(A, w) o2 = getOneBitPos(A, w)[0] if o1 != o2: print(x, y, z) input()
def computeGradients(self, data, s, i): gradwpf = [] gradwpf_bias = [] gradwpb = [] gradwip = [] gradwpi = [] for k in range(self.ns): if k == 0: vb = self.wpf[k](rho(data)) vbhat = self.gb/(self.gb + self.glk + self.ga)*vb gradwpf.append((1/self.batch_size)*(torch.mm(torch.transpose(rho(s[k]) - rho(vbhat), 0, 1),rho(data)))) else: vb = self.wpf[k](rho(s[k - 1])) vbhat = self.gb/(self.gb + self.glk + self.ga)*vb gradwpf.append((1/self.batch_size)*(torch.mm(torch.transpose(rho(s[k]) - rho(vbhat), 0, 1), rho(s[k - 1])))) gradwpf_bias.append((1/self.batch_size)*(rho(s[k]) - rho(vbhat)).sum(0)) del vb, vbhat for k in range(self.ns - 1): vi = self.wip[k](rho(s[k])) vihat = self.gd/(self.gd + self.glk)*vi gradwip.append((1/self.batch_size)*(torch.mm(torch.transpose(rho(i[k + 1]) - rho(vihat), 0, 1), rho(s[k])))) va = self.wpi[k](rho(i[k + 1])) + self.wpb[k](rho(s[k + 1])) gradwpi.append((1/self.batch_size)*(torch.mm(torch.transpose(-va, 0, 1), rho(i[k + 1])))) vtdhat = self.wpb[k](rho(s[k + 1])) gradwpb.append((1/self.batch_size)*(torch.mm(torch.transpose(rho(s[k]) - rho(vtdhat), 0, 1), rho(s[k + 1])))) del vi, vihat, va, vtdhat return gradwpf, gradwpf_bias, gradwpb, gradwpi, gradwip
def stepper(self, data, s, i, track_va = False, **kwargs): dsdt = [] #*****dynamics of the interneurons*****# didt = [] #**************************************# #***track apical voltage***# if track_va: va_topdown = [] va_cancellation = [] #**************************# #Compute derivative of the somatic membrane potential for k in range(len(s)): #Compute basal voltage if k == 0 :#visible layer vb = self.wpf[k](rho(data)) else: vb = self.wpf[k](rho(s[k - 1])) #a)for hidden neurons if k < len(s) - 1: #Compute and optionally store apical voltage va = self.wpi[k](rho(i[k + 1])) + self.wpb[k](rho(s[k + 1])) if track_va: va_topdown.append(self.wpb[k](rho(s[k + 1]))) va_cancellation.append(self.wpi[k](rho(i[k + 1]))) #Compute total derivative (Eq. 1) dsdt.append( -self.glk*s[k] + self.gb*(vb - s[k]) + self.ga*(va - s[k]) + self.noise*torch.randn_like(s[k])) del va #b) for output neurons else: #Compute total derivative (Eq. 1) *with ga = 0*: dsdt.append( -self.glk*s[k] + self.gb*(vb - s[k]) + self.noise*torch.randn_like(s[k])) #Nudging if 'target' in kwargs: dsdt[k] = dsdt[k] + self.gsom*(kwargs['target'] - s[k]) del vb #Compute derivative of the interneuron membrane potential for k in range(len(i)): if i[k] is not None: #Compute basal interneuron voltage vi = self.wip[k - 1](rho(s[k - 1])) #Compute total derivative (Eq. 2) didt.append(-self.glk*i[k] + self.gd*(vi - i[k]) + self.gsom*(s[k] - i[k]) + self.noise*torch.randn_like(i[k])) else: didt.append(None) #Update the values of the neurons for k in range(len(s)): s[k] = s[k] + self.dt*dsdt[k] for k in range(len(i)): if i[k] is not None: i[k] = i[k] + self.dt*didt[k] if not track_va: return s, i else: return s, i, [va_topdown, va_cancellation]
def stepper(self, data, s, inds, target=None, beta=0, return_derivatives=False, inplace=False): dsdt = [] #CLASSIFIER PART #last classifier layer dsdt.append(-s[0] + rho(self.fc[0](s[1].view(s[1].size(0), -1)))) if beta > 0: dsdt[0] = dsdt[0] + beta * (target - s[0]) #middle classifier layer for i in range(1, len(self.size_classifier_tab) - 1): dsdt.append(-s[i] + rho(self.fc[i](s[i + 1].view(s[i + 1].size(0), -1)) + torch.mm(s[i - 1], self.fc[i - 1].weight))) #CONVOLUTIONAL PART #last conv layer s_pool, ind = self.pool(self.conv[0](s[self.nc + 1])) inds[self.nc] = ind dsdt.append(-s[self.nc] + rho(s_pool + torch.mm( s[self.nc - 1], self.fc[-1].weight).view(s[self.nc].size()))) del s_pool, ind #middle layers for i in range(1, self.nconv - 1): s_pool, ind = self.pool(self.conv[i](s[self.nc + i + 1])) inds[self.nc + i] = ind if inds[self.nc + i - 1] is not None: output_size = [ s[self.nc + i - 1].size(0), s[self.nc + i - 1].size(1), self.size_conv_tab[i - 1], self.size_conv_tab[i - 1] ] s_unpool = F.conv_transpose2d(self.unpool( s[self.nc + i - 1], inds[self.nc + i - 1], output_size=output_size), weight=self.conv[i - 1].weight, padding=self.P) dsdt.append(-s[self.nc + i] + rho(s_pool + s_unpool)) del s_pool, s_unpool, ind, output_size #first conv layer s_pool, ind = self.pool(self.conv[-1](data)) inds[-1] = ind if inds[-2] is not None: output_size = [ s[-2].size(0), s[-2].size(1), self.size_conv_tab[-3], self.size_conv_tab[-3] ] s_unpool = F.conv_transpose2d(self.unpool(s[-2], inds[-2], output_size=output_size), weight=self.conv[-2].weight, padding=self.P) dsdt.append(-s[-1] + rho(s_pool + s_unpool)) del s_pool, s_unpool, ind, output_size if not inplace: for i in range(len(s)): s[i] = s[i] + dsdt[i] else: for i in range(len(s)): s[i] += dsdt[i] if return_derivatives: return s, inds, dsdt else: del dsdt return s, inds
def computeGradients(self, beta, data, s, seq): gradw = [] gradw_bias = [] batch_size = s[0].size(0) gradw.append( (1 / (beta * batch_size)) * (torch.mm(torch.transpose(rho(s[0]), 0, 1), rho(s[0])) - torch.mm(torch.transpose(rho(seq[0]), 0, 1), rho(seq[0])))) gradw.append( (1 / (beta * batch_size)) * (torch.mm(torch.transpose(rho(s[0]), 0, 1), rho(s[1])) - torch.mm(torch.transpose(rho(seq[0]), 0, 1), rho(seq[1])))) gradw.append((1 / (beta * batch_size)) * (torch.mm(torch.transpose(rho(s[0]), 0, 1), rho(data)) - torch.mm(torch.transpose(rho(seq[0]), 0, 1), rho(data)))) gradw.append( (1 / (beta * batch_size)) * (torch.mm(torch.transpose(rho(s[1]), 0, 1), rho(s[1])) - torch.mm(torch.transpose(rho(seq[1]), 0, 1), rho(seq[1])))) gradw.append((1 / (beta * batch_size)) * (torch.mm(torch.transpose(rho(s[1]), 0, 1), rho(data)) - torch.mm(torch.transpose(rho(seq[1]), 0, 1), rho(data)))) return gradw, gradw_bias
def computeGradients(self, beta, data, s, seq): gradw = [] gradw_bias = [] batch_size = s[0].size(0) for i in range(self.ns - 1): gradw.append((1 / (beta * batch_size)) * ( torch.mm(torch.transpose(rho(s[i]), 0, 1), rho(s[i + 1])) - torch.mm(torch.transpose(rho(seq[i]), 0, 1), rho(seq[i + 1])))) gradw.append(None) gradw_bias.append( (1 / (beta * batch_size)) * (rho(s[i]) - rho(seq[i])).sum(0)) gradw_bias.append(None) gradw.append((1 / (beta * batch_size)) * torch.mm( torch.transpose(rho(s[-1]) - rho(seq[-1]), 0, 1), rho(data))) gradw_bias.append( (1 / (beta * batch_size)) * (rho(s[-1]) - rho(seq[-1])).sum(0)) return gradw, gradw_bias