def pascals_triangle(n: int = None, **kwargs: dict) -> npNdArray: """Pascal's Triangle Returns a numpy array of the nth row of Pascal's Triangle. n=4 => triangle: [1, 4, 6, 4, 1] => weighted: [0.0625, 0.25, 0.375, 0.25, 0.0625] => inverse weighted: [0.9375, 0.75, 0.625, 0.75, 0.9375] """ n = int(npFabs(n)) if n is not None else 0 # Calculation triangle = npArray([combination(n=n, r=i) for i in range(0, n + 1)]) triangle_sum = npSum(triangle) triangle_weights = triangle / triangle_sum inverse_weights = 1 - triangle_weights weighted = kwargs.pop("weighted", False) inverse = kwargs.pop("inverse", False) if weighted and inverse: return inverse_weights if weighted: return triangle_weights if inverse: return None return triangle
def fibonacci(n: int = 2, **kwargs: dict) -> npNdArray: """Fibonacci Sequence as a numpy array""" n = int(npFabs(n)) if n >= 0 else 2 zero = kwargs.pop("zero", False) if zero: a, b = 0, 1 else: n -= 1 a, b = 1, 1 result = npArray([a]) for _ in range(0, n): a, b = b, a + b result = npAppend(result, a) weighted = kwargs.pop("weighted", False) if weighted: fib_sum = npSum(result) if fib_sum > 0: return result / fib_sum else: return result else: return result
def symmetric_triangle(n: int = None, **kwargs: dict) -> Optional[List[int]]: """Symmetric Triangle with n >= 2 Returns a numpy array of the nth row of Symmetric Triangle. n=4 => triangle: [1, 2, 2, 1] => weighted: [0.16666667 0.33333333 0.33333333 0.16666667] """ n = int(npFabs(n)) if n is not None else 2 triangle = None if n == 2: triangle = [1, 1] if n > 2: if n % 2 == 0: front = [i + 1 for i in range(0, mfloor(n / 2))] triangle = front + front[::-1] else: front = [i + 1 for i in range(0, mfloor(0.5 * (n + 1)))] triangle = front.copy() front.pop() triangle += front[::-1] if kwargs.pop("weighted", False) and isinstance(triangle, list): triangle_sum = npSum(triangle) triangle_weights = triangle / triangle_sum return triangle_weights return triangle
def runBackpropagation(self, net_output_error=1): ''' Backpropagate values from base_frame and weight_bias_frame. ''' if isinstance(net_output_error, list) or isinstance( net_output_error, ndarray): net_output_error = average(net_output_error) shapes = [layer.shape for layer in self.weight_base_frame.layers] shapes.reverse() for indx in range(len(shapes)): layer_index = -(indx + 1) delta_biases = self.weight_base_frame.delta_biases[layer_index] delta_weights = self.weight_base_frame.delta_weights[layer_index] base_layer_index = self.base_frame.getLayerTitle(layer_index) # Derivatives compound due to Calculus Chain Rule as one moves towards inputs recursion_indx = layer_index + 1 if recursion_indx is 0: continue node_count = len(self.base_frame.layers_delta[base_layer_index]) layer_shape = delta_biases.shape recursive_delta_weights = self.weight_base_frame.delta_weights[ recursion_indx] self.base_frame.layers_delta[base_layer_index] = [ npSum(recursive_delta_weights[:, k]) for k in range(node_count) ] delta_nodes = self.base_frame.layers_delta[base_layer_index] for layer_shape_indx in range(layer_shape[1]): self.weight_base_frame.delta_weights[ layer_index][:, layer_shape_indx] = multiply( delta_weights[:, layer_shape_indx], delta_nodes) self.weight_base_frame.delta_biases[ layer_index][:, layer_shape_indx] = multiply( delta_biases[:, layer_shape_indx], delta_nodes) weight_difference = multiply( array(self.weight_base_frame.delta_weights, dtype='object'), -net_output_error) bias_difference = multiply( array(self.weight_base_frame.delta_biases, dtype='object'), -net_output_error) # Brute forcing for time's sake *** NOT EFFICIENT dweights = array( [item[:, :, 0] for item in self.weight_base_frame.layers], dtype='object') dweights = subtract(dweights, weight_difference) dbiases = array( [item[:, :, 1] for item in self.weight_base_frame.layers], dtype='object') dbiases = subtract(dweights, bias_difference) for array_number, layer in enumerate(self.weight_base_frame.layers): for layer_number, nodes in enumerate(layer): for node_number in range(len(nodes)): self.weight_base_frame.layers[array_number][layer_number][ node_number][0] = dweights[array_number][layer_number][ node_number] self.weight_base_frame.layers[array_number][layer_number][ node_number][1] = dbiases[array_number][layer_number][ node_number]
def getResultant(input_array): ''' Get Results of Sigmoid Activation Function ''' return npSum(input_array)
def PMBSegmentation(argv, nameFileOutputXML): inputPath = None outputPath = 'out.lab' boundariesPath = None verbose = False # Communs wLen = 0.016 wStep = 0.008 withEntropy = False with4Hz = False withNBS = False withLS = False moduLen = 1 speech_labels = {0: 'Non Speech', 1: 'Speech'} music_labels = {0: 'Non Music', 1: 'Music'} sort = False # entropy entropyTh = 0.4 # 4 Hz fcenter = 4.0 fwidth = 0.5 normalized = True N = 2048 ordre = 100 nbFilters = 30 energyTh = 1.5 # Music musicLen = 1.0 musicStep = 0.1 maxSegForLength = 1000 thLen = 0.04 thNb = 20 segments = [] boundaries = None # Lecture des arguments opts = argv #print opts i = 0 while (i < len(argv)): #print str(i) if opts[i] == '-h': printhelp() elif opts[i] == '-i': i = i + 1 inputPath = opts[i] elif opts[i] == '-o': outputPath = opts[i] elif opts[i] == '-b': i = i + 1 boundariesPath = opts[i] elif opts[i] == '-v': verbose = True elif opts[i] == '--sorted': sort = True elif opts[i] == '--Entropy': withEntropy = True elif opts[i] == '--4Hz': with4Hz = True elif opts[i] == '--NBS': withNBS = True elif opts[i] == '--LS': withLS = True elif opts[i] == '-w': i = i + 1 wLen = float(opts[i]) elif opts[i] == '-s': i = i + 1 wStep = float(opts[i]) i = i + 1 if inputPath == None: printhelp() exit(1) else: #print "Audio file path : "+ inputPath fe, data = wavread(inputPath) print "Audio file opened : " + inputPath fe = float(fe) m = iinfo(data[0]).max data = [float(d) / m for d in data] demi = int(wLen / 2 * fe) timeScale = range(demi, len(data) - demi, int(wStep * fe)) frames = [data[t - demi:t + demi] for t in timeScale] if withEntropy: if verbose: print 'Analyse de la modulation d\'entropy' entropy_values = [entropy(f) for f in frames] entropy_modulation = computeModulation(entropy_values, moduLen / wStep, withLog=False) with open('entropy.lab', 'w') as f: for t, v in zip(timeScale, entropy_modulation): f.write('%f\t%f\n' % (float(t) / fe, v)) entropy_modulation = [(e / entropyTh) - 1 if e < 2 * entropyTh else 1 for e in entropy_modulation] segments_entropy = decoupe(entropy_modulation) segments_entropy = [(s[0] * wStep, s[1] * wStep, speech_labels[s[2]] + ' (Entropy)') for s in segments_entropy] segments.extend(segments_entropy) if with4Hz: if verbose: print 'Analyse de la modulation d\'energie a 4Hz' Wo = fcenter / fe Wn = [Wo - (fwidth / 2) / fe, Wo + (fwidth / 2) / fe] num = firwin(ordre, Wn, pass_zero=False) melFilter = melFilterBank(nbFilters, N, fe) hw = hamming(wLen * fe) energy = [ dot(abs(rfft(hw * f, n=2 * N)[0:N])**2, melFilter) for f in frames ] # transposition de list of list energy = lfilter(num, 1, map(list, zip(*energy)), 0) energy = sum(energy) if normalized: energy = energy / mean(energy) energy_modulation = computeModulation(energy, moduLen / wStep, withLog=True) with open('energy.lab', 'w') as f: for t, v in zip(timeScale, energy_modulation): f.write('%f\t%f\n' % (float(t) / fe, v)) energy_modulation = [(e / energyTh) - 1 if e < 2 * energyTh else 1 for e in energy_modulation] segments_energy = decoupe(energy_modulation) segments_energy = [(s[0] * wStep, s[1] * wStep, speech_labels[s[2]] + ' (4Hz)') for s in segments_energy] segments.extend(segments_energy) if withLS: if verbose: print 'Analyse de la longueur des segments' if boundariesPath == None: a, b = segment(data, fe) boundaries = [(float(st[0]) / fe, ) for st in a] else: boundaries = readBoundaries(boundariesPath) times = array([b[0] for b in boundaries]) demi = musicLen / 2 timeScale = arange(demi, times[-1] - demi, musicStep) # On prend les plus petits !! segframes = [ sorted(diff(times[logical_and(times >= t - demi, times <= t + demi)]), reverse=True) for t in timeScale ] lengths = [mean(s[:min([maxSegForLength, len(s)])]) for s in segframes] with open('LS.lab', 'w') as f: for t, v in zip(timeScale, lengths): f.write('%f\t%f\n' % (float(t) / fe, v)) lengths = [(l / thLen) - 1 if l < 2 * thLen else 1 for l in lengths] segments_length = decoupe(lengths) segments_length = [(s[0] * musicStep, s[1] * musicStep, music_labels[s[2]] + ' (LS)') for s in segments_length] segments.extend(segments_length) if withNBS: if verbose: print 'Analyse du nombre de segments' if boundariesPath == None: if boundaries == None: a, b = segment(data, fe) boundaries = [(float(st[0]) / fe, ) for st in a] else: if boundaries == None: boundaries = readBoundaries(boundariesPath) times = array([b[0] for b in boundaries]) demi = musicLen / 2 timeScale = arange(demi, times[-1] - demi, musicStep) segnb = [ float(npSum(logical_and(times >= t - demi, times <= t + demi))) for t in timeScale ] with open('NBS.lab', 'w') as f: for t, v in zip(timeScale, segnb): f.write('%f\t%f\n' % (float(t) / fe, v)) segnb = [-(l / thNb) + 1 if l < 2 * thNb else 1 for l in segnb] segments_nb = decoupe(segnb) segments_nb = [(s[0] * musicStep, s[1] * musicStep, music_labels[s[2]] + ' (NBS)') for s in segments_nb] segments.extend(segments_nb) if sort: segments = sorted(segments, key=lambda x: x[0]) v = writeToXML(segments, nameFileOutputXML, withNBS, with4Hz, withLS, withEntropy) return v #print "Audio file processed sucessfully" '''