Esempio n. 1
0
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
Esempio n. 2
0
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
Esempio n. 3
0
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
Esempio n. 4
0
 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]
Esempio n. 5
0
 def getResultant(input_array):
     ''' Get Results of Sigmoid Activation Function '''
     return npSum(input_array)
Esempio n. 6
0
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"
    '''