def compLongRepresentationSingle(net, waves, xp, trimInputLen=True): net.reset() x = waves batchSize, waveLen = x.shape inputLen = totalInputLength(net.structure) x = np.concatenate((np.zeros((batchSize, inputLen - 1), x.dtype), x), axis=1) x = x[:, newaxis, :, newaxis] x = xp.asarray(x, float32) x = Variable(x) layerRepre = compRepresentationSingle(net, x) for li, r in enumerate(layerRepre): r = r[..., 0] if xp != np: r = cupy.asnumpy(r) r = r[..., -waveLen:] if trimInputLen: r = r[..., inputLen - 1:] layerRepre[li] = r layerRepre = np.stack(layerRepre, axis=0) return layerRepre
def compNoiseAmAveSyn(stimSec, waveFs, fileModel, architecture, gpu_id, trainingRms): with chainer.using_config("enable_backprop", False): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np modDepth = 1 waveLen = int(stimSec * waveFs) np.random.seed(0) times = np.arange(waveLen) / waveFs freqs = np.logspace(np.log10(1), np.log10(2000), 2**8) meanSize = 2**2 #we used 2**4 in our paper batchSizeUpper = meanSize batchSize = np.array_split(np.arange(meanSize), int(np.ceil(meanSize / batchSizeUpper))) batchSize = [len(x) for x in batchSize] segmentSecUpper = 2 #decrease this for a GPU with smaller memory segmentLenUpper = int(segmentSecUpper * waveFs) net = loadNet(architecture, fileModel) if gpu_id >= 0: net.to_gpu(gpu_id) inputLen = totalInputLength(net.structure) freqResponse = [] for fi, freq in enumerate(freqs): print("Conducting physiology:", "stimulus AM freq:", freq) cos, sin = vectorCosSin(freq, inputLen, waveLen, waveFs) batchResponse = [] for bi, bs in enumerate(batchSize): waves = np.random.randn(bs, waveLen) waves *= (1 - modDepth * np.cos(freq * 2 * np.pi * times)) waves = scaleRms(waves, trainingRms) # repre=compLongRepresentation(net, waves, segmentLenUpper, waveLen, xp) #compLongRepresentationSingle() returns the same result when trimInputLen=True repre = compLongRepresentationSingle(net, waves, xp) repre += 1 #elu ave = repre.mean(axis=-1) s = repre.sum(axis=-1) syn = (((repre * cos).sum(axis=-1) / s)**2 + ((repre * sin).sum(axis=-1) / s)**2)**0.5 syn[s == 0] = 0 resp = np.stack((ave, syn), axis=0) #shape=(type, layer, batch, channel) batchResponse.append(resp) batchResponse = np.concatenate(batchResponse, axis=-2) batchResponse = batchResponse.mean( axis=-2) #shape=(type, layer, channel) freqResponse.append(batchResponse) freqResponse = np.array( freqResponse) #shape=(freq, type, layer, channel) return freqResponse
def train(architecture, waves, infos, gpu_id, waveFs, numEpoch, seed): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np inputLength = totalInputLength(architecture) labels = getLabels() numLabel = len(labels) groupFold = ((0, 1, 2), (3, ), (4, )) insLabelSize = 2**2 np.random.seed(seed) net = Net(numLabel, architecture, functions.elu) # opt=Eve(1e-4) opt = optimizers.Adam(1e-4) opt.setup(net) if gpu_id >= 0: net.to_gpu(gpu_id) insFold = set(itertools.chain.from_iterable(groupFold[:2])) insLabelWave = groupLabelWave((insFold, ), infos)[0] insLabelWaveIndex = [[] for i in range(len(labels))] for li, la in enumerate(labels): for i in insLabelWave[la]: wave = waves[i] timeIndex = np.arange(len(wave)) waveIndex = np.ones(len(wave), int32) * i index = np.stack((waveIndex, timeIndex), axis=1) insLabelWaveIndex[li].append(index) insLabelWaveIndex[li] = np.concatenate(insLabelWaveIndex[li], axis=0) insRemainingLabelWave = [ np.random.permutation(insLabelWaveIndex[li]) for li in range(len(labels)) ] for epoch in range(numEpoch): print("Training: Epoch", epoch, "/", numEpoch) x, tr = makeInpTru(insLabelWaveIndex, waves, insRemainingLabelWave, inputLength, insLabelSize, numLabel) x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net.callSingle(x, True) tr = tr[..., newaxis, newaxis] tr = xp.asarray(tr) e = functions.softmax_cross_entropy(x, tr) net.cleargrads() e.backward() e.unchain_backward() opt.update(loss=e.data) # opt.update() return net
def compLongRepresentation(net, waves, segmentLenUpper, waveLen, xp, trimInputLen=True): ''' Deprecated. compLongRepresentationSingle() returns the same result when trimInputLen=True ''' segmentTimes = np.array_split(np.arange(waveLen), int(np.ceil(waveLen / segmentLenUpper))) segmentTimes = [(x[0], x[-1] + 1) for x in segmentTimes] net.reset() repre = None for si, (t0, t1) in enumerate(segmentTimes): x = waves[:, t0:t1] x = x[:, newaxis, :, newaxis] x = xp.asarray(x, float32) x = Variable(x) r = compRepresentation(net, x) r = xp.stack(r, axis=0) r = r[..., 0] if repre is None: repre = np.empty((r.shape[0], len(waves), r.shape[2], waveLen), r.dtype) if xp != np: r = cupy.asnumpy(r) repre[..., t0:t1] = r if trimInputLen: inputLen = totalInputLength(net.structure) repre = repre[..., inputLen - 1:] return repre
def evaluate(architecture, waves, trues, labels, infos, gpu_id, waveFs, fileParam): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np valIndex = coreTestIndex(infos) devBatchSizeUpper = 2**8 devSegmentSecUpper = 0.1 devSegmentLenUpper = int(devSegmentSecUpper * waveFs) devIndex = sorted(valIndex, key=lambda i: len(waves[i])) devIndex = np.array(devIndex) devBatchIndex = np.array_split( devIndex, int(np.ceil(len(devIndex) / devBatchSizeUpper))) devLabelSize = np.zeros(len(labels), int32) for i in devIndex: for li, la in enumerate(labels): devLabelSize[li] += (trues[i] == li).sum() net = Net(len(labels), architecture, functions.elu) serializers.load_hdf5(fileParam, net) if gpu_id >= 0: net.to_gpu(gpu_id) inputLength = totalInputLength(architecture) with chainer.using_config("enable_backprop", False): confusion = np.zeros((len(labels), len(labels)), int32) for index in devBatchIndex: waveLen = len(waves[index[-1]]) segmentTimes = np.array_split( np.arange(waveLen), int(np.ceil(waveLen / devSegmentLenUpper))) net.reset() for si, segTime in enumerate(segmentTimes): t0 = segTime[0] t1 = segTime[-1] + 1 x = np.zeros((len(index), t1 - t0), float32) tr = -np.ones((len(index), t1 - t0), int32) for xi, wi in enumerate(index): if len(waves[wi]) > t0: w = waves[wi][t0:t1] x[xi, :len(w)] = w if len(waves[wi]) > t0: tr[xi, :len(w)] = trues[wi][t0:t1] x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net(x, False) x = xp.argmax(x.data, axis=1) if cupy is not None: x = cupy.asnumpy(x) x = x.flatten() tr = tr.flatten() for xi, ti in zip(x, tr): if ti >= 0: confusion[ti, xi] += 1 assert (np.sum(confusion, axis=1) == devLabelSize).all() return confusion
def train(architecture, waves, trues, labels, infos, gpu_id, waveFs, numEpoch, seed): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np valIndex = coreTestIndex(infos) np.random.seed(0) insIndex, = traGroupIndex(infos, 1) insIndex = np.array(insIndex) insLabelIndexTime = makeLabelIndexTime(insIndex, labels, trues) insLabelSize = 2**2 #la12 tot4096 ch128 inputLength = totalInputLength(architecture) np.random.seed(seed) net = Net(len(labels), architecture, functions.elu) opt = optimizers.Adam(1e-4) # opt=Eve(1e-4) opt.setup(net) if gpu_id >= 0: net.to_gpu(gpu_id) remainingInsLabelIndexTime = [ np.random.permutation(lt) for lt in insLabelIndexTime ] for epoch in range(numEpoch): print("Training: Epoch", epoch, "/", numEpoch) for li, lit in enumerate(remainingInsLabelIndexTime): if len(lit) < insLabelSize: remainingInsLabelIndexTime[li] = np.concatenate( (lit, np.random.permutation(insLabelIndexTime[li]))) x, tr = makeInpTru(labels, insLabelSize, inputLength, remainingInsLabelIndexTime, waves, trues) x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net.callSingle(x, True) tr = tr[..., newaxis, newaxis] tr = xp.asarray(tr) e = functions.softmax_cross_entropy(x, tr, normalize=True) net.cleargrads() e.backward() e.unchain_backward() opt.update() # opt.update(loss=e.data) return net
def compToneAveSyn(stimSec, waveFs, fileModel, architecture, gpu_id, trainingRms): with chainer.using_config("enable_backprop", False): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np waveLen = int(stimSec * waveFs) batchSizeUpper = 1 times = np.arange(waveLen) / waveFs freqs = np.logspace(np.log10(100), np.log10(5000), 2**8) ampScale = np.logspace(np.log10(1 / 512), np.log10(1), 2**8) batchAmps = np.array_split( ampScale, int(np.ceil(len(ampScale) / batchSizeUpper))) segmentSecUpper = 2 segmentLenUpper = int(segmentSecUpper * waveFs) net = loadNet(architecture, fileModel) if gpu_id >= 0: net.to_gpu(gpu_id) inputLen = totalInputLength(net.structure) freqResponse = [] for fi, freq in enumerate(freqs): cos, sin = vectorCosSin(freq, inputLen, waveLen, waveFs) batchResponse = [] for bi, ba in enumerate(batchAmps): waves = np.sin(freq * 2 * np.pi * times) waves = scaleRms(waves, trainingRms) waves = waves * ba[:, newaxis] #shape=(amp, length) # repre=compLongRepresentation(net, waves, segmentLenUpper, waveLen, xp) #compLongRepresentationSingle() returns the same result when trimInputLen=True repre = compLongRepresentationSingle(net, waves, xp) repre += 1 #elu ave = repre.mean(axis=-1) s = repre.sum(axis=-1) syn = (((repre * cos).sum(axis=-1) / s)**2 + ((repre * sin).sum(axis=-1) / s)**2)**0.5 syn[s == 0] = 0 resp = np.stack((ave, syn), axis=0) #shape=(type, layer, amp, channel) batchResponse.append(resp) batchResponse = np.concatenate( batchResponse, axis=-2) #shape=(type, layer, amp, channel) freqResponse.append(batchResponse) freqResponse = np.array( freqResponse) #shape=(freq, type, layer, amp, channel) return freqResponse
def compSilenceAveSyn(stimSec, waveFs, fileModel, architecture, gpu_id): with chainer.using_config("enable_backprop", False): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np waveLen = int(stimSec * waveFs) freqs = np.logspace(np.log10(100), np.log10(5000), 2**8) segmentSecUpper = 2 segmentLenUpper = int(segmentSecUpper * waveFs) net = loadNet(architecture, fileModel) if gpu_id >= 0: net.to_gpu(gpu_id) inputLen = totalInputLength(net.structure) waves = np.zeros((1, waveLen), float32) # repre=compLongRepresentation(net, waves, segmentLenUpper, waveLen, xp) #shape=(layer, 1, channel, length) #compLongRepresentationSingle() returns the same result when trimInputLen=True repre = compLongRepresentationSingle(net, waves, xp) repre += 1 #elu repre = repre[:, 0, :, :] #shape=(layer, channel, length) ave = repre.mean(axis=-1) #shape=(layer, channel) freqResponse = [] for fi, freq in enumerate(freqs): cos, sin = vectorCosSin(freq, inputLen, waveLen, waveFs) s = repre.sum(axis=-1) syn = (((repre * cos).sum(axis=-1) / s)**2 + ((repre * sin).sum(axis=-1) / s)**2)**0.5 syn[s == 0] = 0 freqResponse.append(syn) freqResponse = np.array(freqResponse) #shape=(freq, layer, channel) return ave, freqResponse
def findNumEpoch(architecture, waves, infos, gpu_id, waveFs): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np inputLength = totalInputLength(architecture) labels = getLabels() numLabel = len(labels) groupFold = ((0, 1, 2), (3, ), (4, )) np.random.seed() seed = np.random.randint(0, np.iinfo(int32).max) np.random.seed(seed) net = Net(numLabel, architecture, functions.elu) # opt=Eve(1e-4) opt = optimizers.Adam(1e-4) opt.setup(net) if gpu_id >= 0: net.to_gpu(gpu_id) insLabelSize = 2**2 devSize = 2**1 devSegmentSecUpper = 10 devEpoch = 2**5 convergenceEpoch = 2**5 * devEpoch devSegmentLenUpper = int(devSegmentSecUpper * waveFs) devFold = sorted(set(groupFold[1])) devLabelWave = groupLabelWave((devFold, ), infos)[0] devLabelWave = list( itertools.chain.from_iterable([[(li, i) for i in devLabelWave[la]] for li, la in enumerate(labels)])) devLabelWave = sorted(devLabelWave, key=lambda lw: len(waves[lw[1]])) devBatchIndex = np.array_split(np.arange(len(devLabelWave)), int(np.ceil(len(devLabelWave) / devSize))) devLabelSize = np.zeros(numLabel, int32) for li, wi in devLabelWave: devLabelSize[li] += len(waves[wi]) devWaves = {} for li, wi in devLabelWave: wave = waves[wi] wave = np.concatenate((wave, np.zeros((inputLength - 1) // 2, float32))) devWaves[wi] = wave insFold = sorted(set(groupFold[0])) insLabelWave = groupLabelWave((insFold, ), infos)[0] insLabelWaveIndex = [[] for i in range(len(labels))] for li, la in enumerate(labels): for i in insLabelWave[la]: wave = waves[i] timeIndex = np.arange(len(wave)) waveIndex = np.ones(len(wave), int32) * i index = np.stack((waveIndex, timeIndex), axis=1) insLabelWaveIndex[li].append(index) insLabelWaveIndex[li] = np.concatenate(insLabelWaveIndex[li], axis=0) insRemainingLabelWave = [ np.random.permutation(insLabelWaveIndex[li]) for li in range(len(labels)) ] epoch = 0 bestEpoch = 0 epochIncorrect = {} while epoch < bestEpoch + convergenceEpoch: x, tr = makeInpTru(insLabelWaveIndex, waves, insRemainingLabelWave, inputLength, insLabelSize, numLabel) x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net.callSingle(x, True) tr = tr[..., newaxis, newaxis] tr = xp.asarray(tr) e = functions.softmax_cross_entropy(x, tr) net.cleargrads() e.backward() e.unchain_backward() # opt.update(loss=e.data) opt.update() if epoch % devEpoch != devEpoch - 1: epoch += 1 continue incorrect = xp.zeros(numLabel, int32) with chainer.using_config("enable_backprop", False): for bi, index in enumerate(devBatchIndex): waveIndex = np.array([devLabelWave[i][1] for i in index]) tru = np.array([devLabelWave[i][0] for i in index]) waveLen = len(devWaves[waveIndex[-1]]) segmentTimes = np.array_split( np.arange(waveLen), int(np.ceil((waveLen) / devSegmentLenUpper))) net.reset() for si, segTime in enumerate(segmentTimes): t0 = segTime[0] t1 = segTime[-1] + 1 x = np.zeros((len(index), t1 - t0), float32) tr = -np.ones((len(index), t1 - t0), int32) for xi, wi in enumerate(waveIndex): if len(devWaves[wi]) <= t0: continue w = devWaves[wi][t0:t1] x[xi, :len(w)] = w tr[xi, :len(w)] = tru[xi] if t0 < (inputLength - 1) // 2: tr[:, :(inputLength - 1) // 2 - t0] = -1 x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net(x, False) x.unchain_backward() x = xp.argmax(x.data, axis=1) tr = tr[..., newaxis] tr = xp.asarray(tr) for li, la in enumerate(labels): incorrect[li] += (x[tr == li] != li).sum() net.reset() if gpu_id >= 0: incorrect = cupy.asnumpy(incorrect) incorrect = (incorrect / devLabelSize).mean() print("epoch", epoch, "incorrect", incorrect) if len(epochIncorrect) == 0 or incorrect < epochIncorrect[bestEpoch]: bestEpoch = epoch epochIncorrect[epoch] = incorrect epoch += 1 devEpochs = np.array(sorted(epochIncorrect), int32) bestScore = epochIncorrect[bestEpoch] epochIncorrect = np.array([epochIncorrect[ep] for ep in devEpochs]) return bestEpoch, bestScore, seed
def evaluate(architecture, waves, infos, gpu_id, waveFs, fileParam): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np inputLength = totalInputLength(architecture) labels = getLabels() numLabel = len(labels) groupFold = ((0, 1, 2), (3, ), (4, )) devSize = 2**1 devSegmentSecUpper = 10 net = Net(numLabel, architecture, functions.elu) serializers.load_hdf5(fileParam, net) if gpu_id >= 0: net.to_gpu(gpu_id) devSegmentLenUpper = int(devSegmentSecUpper * waveFs) devFold = sorted(set(groupFold[2])) devLabelWave = groupLabelWave((devFold, ), infos)[0] devLabelWave = list( itertools.chain.from_iterable([[(li, i) for i in devLabelWave[la]] for li, la in enumerate(labels)])) devLabelWave = sorted(devLabelWave, key=lambda lw: len(waves[lw[1]])) devBatchIndex = np.array_split(np.arange(len(devLabelWave)), int(np.ceil(len(devLabelWave) / devSize))) devLabelSize = np.zeros(numLabel, int32) for li, wi in devLabelWave: devLabelSize[li] += len(waves[wi]) devWaves = {} for li, wi in devLabelWave: wave = waves[wi] wave = np.concatenate((wave, np.zeros((inputLength - 1) // 2, float32))) devWaves[wi] = wave with chainer.using_config("enable_backprop", False): confusion = np.zeros((numLabel, numLabel), int32) for bi, index in enumerate(devBatchIndex): waveIndex = np.array([devLabelWave[i][1] for i in index]) tru = np.array([devLabelWave[i][0] for i in index]) waveLen = len(devWaves[waveIndex[-1]]) segmentTimes = np.array_split( np.arange(waveLen), int(np.ceil( (waveLen) / devSegmentLenUpper))) net.reset() for si, segTime in enumerate(segmentTimes): t0 = segTime[0] t1 = segTime[-1] + 1 x = np.zeros((len(index), t1 - t0), float32) tr = -np.ones((len(index), t1 - t0), int32) for xi, wi in enumerate(waveIndex): if len(devWaves[wi]) <= t0: continue w = devWaves[wi][t0:t1] x[xi, :len(w)] = w tr[xi, :len(w)] = tru[xi] if t0 < (inputLength - 1) // 2: tr[:, :(inputLength - 1) // 2 - t0] = -1 x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net(x, False) x.unchain_backward() x = xp.argmax(x.data, axis=1) if gpu_id >= 0: x = cupy.asnumpy(x) x = x.flatten() tr = tr.flatten() for xi, ti in zip(x[tr >= 0], tr[tr >= 0]): confusion[ti, xi] += 1 net.reset() assert (np.sum(confusion, axis=1) == devLabelSize).all() return confusion
def findNumEpoch(architecture, waves, trues, labels, infos, gpu_id, waveFs): if cupy is not None and gpu_id >= 0: xp = cupy cupy.cuda.Device(gpu_id).use() else: xp = np valIndex = coreTestIndex(infos) np.random.seed(0) insIndex, devIndex = traGroupIndex(infos, 2) insIndex = np.array(insIndex) insLabelIndexTime = makeLabelIndexTime(insIndex, labels, trues) insLabelSize = 2**2 devEpoch = 2**5 convergenceEpoch = 2**5 * devEpoch devBatchSizeUpper = 2**8 devSegmentSecUpper = 0.1 devSegmentLenUpper = int(devSegmentSecUpper * waveFs) devIndex = sorted(devIndex, key=lambda i: len(waves[i])) devIndex = np.array(devIndex) devBatchIndex = np.array_split( devIndex, int(np.ceil(len(devIndex) / devBatchSizeUpper))) devLabelSize = np.zeros(len(labels), int32) for i in devIndex: for li, la in enumerate(labels): devLabelSize[li] += (trues[i] == li).sum() inputLength = totalInputLength(architecture) np.random.seed() seed = np.random.randint(0, np.iinfo(int32).max) np.random.seed(seed) net = Net(len(labels), architecture, functions.elu) opt = optimizers.Adam(1e-4) # opt=Eve(1e-4) opt.setup(net) if gpu_id >= 0: net.to_gpu(gpu_id) remainingInsLabelIndexTime = [ np.random.permutation(lt) for lt in insLabelIndexTime ] epoch = 0 bestEpoch = 0 epochIncorrect = {} while epoch < bestEpoch + convergenceEpoch: for li, lit in enumerate(remainingInsLabelIndexTime): if len(lit) < insLabelSize: remainingInsLabelIndexTime[li] = np.concatenate( (lit, np.random.permutation(insLabelIndexTime[li]))) x, tr = makeInpTru(labels, insLabelSize, inputLength, remainingInsLabelIndexTime, waves, trues) x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net.callSingle(x, True) tr = tr[..., newaxis, newaxis] tr = xp.asarray(tr) e = functions.softmax_cross_entropy(x, tr, normalize=True) net.cleargrads() e.backward() e.unchain_backward() opt.update() # opt.update(loss=e.data) if epoch % devEpoch != devEpoch - 1: epoch += 1 continue incorrect = xp.zeros(len(labels), int32) with chainer.using_config("enable_backprop", False): for index in devBatchIndex: waveLen = len(waves[index[-1]]) segmentTimes = np.array_split( np.arange(waveLen), int(np.ceil(waveLen / devSegmentLenUpper))) net.reset() for si, segTime in enumerate(segmentTimes): t0 = segTime[0] t1 = segTime[-1] + 1 x = np.zeros((len(index), t1 - t0), float32) tr = -np.ones((len(index), t1 - t0), int32) for xi, wi in enumerate(index): if len(waves[wi]) > t0: w = waves[wi][t0:t1] x[xi, :len(w)] = w if len(waves[wi]) > t0: tr[xi, :len(w)] = trues[wi][t0:t1] x = x[:, newaxis, :, newaxis] x = xp.asarray(x) x = Variable(x) x = net(x, False) x.unchain_backward() x = xp.argmax(x.data, axis=1) tr = tr[..., newaxis] tr = xp.asarray(tr) for li, la in enumerate(labels): incorrect[li] += (x[tr == li] != li).sum() net.reset() if cupy is not None: incorrect = cupy.asnumpy(incorrect) incorrect = (incorrect / devLabelSize).mean() print("epoch", epoch, "incorrect", incorrect) if len(epochIncorrect) == 0 or incorrect < min( [epochIncorrect[ep] for ep in epochIncorrect]): bestEpoch = epoch epochIncorrect[epoch] = incorrect epoch += 1 devEpochs = np.array(sorted(epochIncorrect), int32) epochIncorrect = np.array([epochIncorrect[ep] for ep in devEpochs]) bestIncorrect = epochIncorrect.min() return bestEpoch, bestIncorrect, seed