示例#1
0
 def execute(self, arff_data, attributes, X):
     base_width = np.array(arff_data['data'][:, attributes.index('baseWidth')], dtype='float64')
     target_width = np.array(arff_data['data'][:, attributes.index('targetWidth')], dtype='float64')
     base_height = np.array(arff_data['data'][:, attributes.index('baseHeight')], dtype='float64')
     target_height = np.array(arff_data['data'][:, attributes.index('targetHeight')], dtype='float64')
     base_viewport = np.array(arff_data['data'][:, attributes.index('baseViewportWidth')], dtype='float64')
     target_viewport = np.array(arff_data['data'][:, attributes.index('targetViewportWidth')], dtype='float64')
     X.append(np.abs((base_width - target_width)/np.maximum(np.abs(base_viewport - target_viewport), 1)))
     X.append(np.abs((base_height - target_height)/np.maximum(np.maximum(base_height, target_height), 1)))
     arff_data['features'] = arff_data['features'] + ['width_comp', 'height_comp']
     return X
    def execute(self, arff_data):
        attributes = [attribute[0] for attribute in arff_data['attributes']]
        dataset = arff_data['data']

        X = (arff_data['X'].T.tolist() if 'X' in arff_data else [])

        base_height = np.array(dataset[:, attributes.index('baseHeight')],
                               dtype='float64')
        target_height = np.array(dataset[:,
                                         attributes.index('targetHeight')],
                                 dtype='float64')
        base_width = np.array(dataset[:, attributes.index('baseWidth')],
                              dtype='float64')
        target_width = np.array(dataset[:, attributes.index('targetWidth')],
                                dtype='float64')
        X.append(
            np.minimum(base_height * base_width, target_height * target_width))

        base_x = np.array(dataset[:, attributes.index('baseX')],
                          dtype='float64')
        target_x = np.array(dataset[:, attributes.index('targetX')],
                            dtype='float64')
        base_y = np.array(dataset[:, attributes.index('baseY')],
                          dtype='float64')
        target_y = np.array(dataset[:, attributes.index('targetY')],
                            dtype='float64')
        X.append(
            np.sqrt(
                np.power(np.abs(base_x - target_x), 2) +
                np.power(np.abs(base_y - target_y), 2)))

        X.append(
            np.abs((base_height * base_width) -
                   (target_height * target_width)) / np.maximum(
                       np.minimum(base_height * base_width, target_height *
                                  target_width), np.ones(len(base_height))))

        X.append(dataset[:, attributes.index('chiSquared')])

        arff_data['X'] = np.array(X, dtype='float64').T
        prev_features = (arff_data['features']
                         if 'features' in arff_data else [])
        arff_data['features'] = prev_features + [
            'area', 'displacement', 'sdr', 'chisquared'
        ]
        arff_data['y'] = np.array(
            arff_data['data'][:, attributes.index(self._class_attr)],
            dtype='int16')
        return arff_data
示例#3
0
	def train(self, X, y, learning_rate = 0.01, update_size = None):

		assert len(np.shape(X)) == 2, "Invalid input shape. The input must be 2d (batch, input_dim)"
		batch_size, input_dim = np.shape(X)
		assert self.input_dim == input_dim, "Unmatch input_dim."


		X = np.column_stack((X, np.ones((batch_size, 1))))
		y = y.reshape((-1, self.output_dim))
		
		if self.updateMethod == "closed-form":
			# check whether the matrix can be inversed
			assert np.linalg.det(X) != 0, "This matrix cann't be inversed."
			
			# update the parameters
			self.w = np.linalg.inv(np.dot(X.T, X))  
		    self.w = np.dot(self.w, X.T)
		    self.w = np.dot(self.w, y)

		    # predict under the train set
		    Y_predict = np.dot(X, self.w)  
		    # calculate the absolute differences
		    loss_train = np.average(np.abs(Y_predict - y))  

		    return Y_predict, loss_train
def spec(windowSize, stepSize, input, fftMag, sr):

    windowSize = int(windowSize)
    stepSize = int(stepSize)
    numberOfSteps = int(math.floor((len(input) - windowSize) / stepSize) + 1)
    spectrogram = np.zeros((int(fftMag / 2), numberOfSteps))
    timeArray = np.zeros((numberOfSteps))
    for i in range(numberOfSteps):
        currentWindow = input[stepSize * i:(stepSize * i) + windowSize]
        transformedWindow = scipy.fft.fft(currentWindow, n=fftMag)
        truncatedWindow = transformedWindow[:int(fftMag / 2)]
        spectrogram[:, i] = np.log(np.abs(truncatedWindow) + 1)
        timeArray[i] = (stepSize * i + (stepSize * i + windowSize)) / (2 * sr)
    return spectrogram, timeArray
示例#5
0
def rotate_bound(image, angle):
    # grab the dimensions of the image and then determine the
    # center
    (h, w) = image.shape[:2]
    (cX, cY) = (w // 2, h // 2)

    # grab the rotation matrix (applying the negative of the
    # angle to rotate clockwise), then grab the sine and cosine
    # (i.e., the rotation components of the matrix)
    M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
    cos = np.abs(M[0, 0])
    sin = np.abs(M[0, 1])

    # compute the new bounding dimensions of the image
    nW = int((h * sin) + (w * cos))
    nH = int((h * cos) + (w * sin))

    # adjust the rotation matrix to take into account translation
    M[0, 2] += (nW / 2) - cX
    M[1, 2] += (nH / 2) - cY

    # perform the actual rotation and return the image
    return cv2.warpAffine(image, M, (nW, nH))
示例#6
0
 def execute(self, arff_data, attributes, X):
     base_width = np.array(arff_data['data'][:, attributes.index('baseWidth')], dtype='float64')
     target_width = np.array(arff_data['data'][:, attributes.index('targetWidth')], dtype='float64')
     base_viewport = np.array(arff_data['data'][:, attributes.index('baseViewportWidth')], dtype='float64')
     target_viewport = np.array(arff_data['data'][:, attributes.index('targetViewportWidth')], dtype='float64')
     base_left = np.array(arff_data['data'][:, attributes.index('baseX')], dtype='float64')
     base_right = np.array(base_viewport - (base_left + base_width), dtype='float64')
     target_left = np.array(arff_data['data'][:, attributes.index('targetX')], dtype='float64')
     target_right = np.array(target_viewport - (target_left + target_width), dtype='float64')
     X.append(np.abs((base_left - target_left) / np.maximum(np.abs(base_viewport - target_viewport), 1)))
     X.append(np.abs((base_right - target_right) / np.maximum(np.abs(base_viewport - target_viewport), 1)))
     base_y = np.array(arff_data['data'][:, attributes.index('baseY')], dtype='float64')
     target_y = np.array(arff_data['data'][:, attributes.index('targetY')], dtype='float64')
     X.append(np.abs((base_y - target_y) / np.maximum(np.abs(base_viewport - target_viewport), 1)))
     arff_data['features'] = arff_data['features'] + ['left_comp', 'right_comp', 'y_comp']
     return X
    def execute(self, arff_data, attributes, X):
        nrows = len(X) if len(X) > 0 else 1

        base_x = np.array(arff_data['data'][:, attributes.index('baseX')], dtype='float64')
        base_y = np.array(arff_data['data'][:, attributes.index('baseY')], dtype='float64')
        base_height = np.array(arff_data['data'][:, attributes.index('baseHeight')], dtype='float64')
        base_width = np.array(arff_data['data'][:, attributes.index('baseWidth')], dtype='float64')
        target_x = np.array(arff_data['data'][:, attributes.index('targetX')], dtype='float64')
        target_y = np.array(arff_data['data'][:, attributes.index('targetY')], dtype='float64')
        target_height = np.array(arff_data['data'][:, attributes.index('targetHeight')], dtype='float64')
        target_width = np.array(arff_data['data'][:, attributes.index('targetWidth')], dtype='float64')

        base_parent_x = np.array(arff_data['data'][:, attributes.index('baseParentX')], dtype='float64')
        base_parent_y = np.array(arff_data['data'][:, attributes.index('baseParentY')], dtype='float64')
        target_parent_x = np.array(arff_data['data'][:, attributes.index('targetParentX')], dtype='float64')
        target_parent_y = np.array(arff_data['data'][:, attributes.index('targetParentY')], dtype='float64')

        base_p_sibling_x = np.array(arff_data['data'][:, attributes.index('basePreviousSiblingLeft')], dtype='float64')
        base_p_sibling_y = np.array(arff_data['data'][:, attributes.index('basePreviousSiblingTop')], dtype='float64')
        target_p_sibling_x = np.array(arff_data['data'][:, attributes.index('targetPreviousSiblingLeft')], dtype='float64')
        target_p_sibling_y = np.array(arff_data['data'][:, attributes.index('targetPreviousSiblingTop')], dtype='float64')

        base_n_sibling_x = np.array(arff_data['data'][:, attributes.index('baseNextSiblingLeft')], dtype='float64')
        base_n_sibling_y = np.array(arff_data['data'][:, attributes.index('baseNextSiblingTop')], dtype='float64')
        target_n_sibling_x = np.array(arff_data['data'][:, attributes.index('targetNextSiblingLeft')], dtype='float64')
        target_n_sibling_y = np.array(arff_data['data'][:, attributes.index('targetNextSiblingTop')], dtype='float64')

        X.append(np.abs((base_x - base_parent_x) - (target_x - target_parent_x)) / np.minimum(target_width, base_width))
        X.append(np.abs((base_y - base_parent_y) - (target_y - target_parent_y)) / np.minimum(target_height, base_height))

        X.append(np.abs((base_x - base_p_sibling_x) - (target_x - target_p_sibling_x)) /
                np.minimum(target_width, base_width))
        X.append(np.abs((base_y - base_p_sibling_y) - (target_y - target_p_sibling_y)) /
                np.minimum(target_height, base_height))

        X.append(np.abs((base_x - base_n_sibling_x) - (target_x - target_n_sibling_x)) /
                np.minimum(target_width, base_width))
        X.append(np.abs((base_y - base_n_sibling_y) - (target_y - target_n_sibling_y)) /
                np.minimum(target_height, base_height))

        arff_data['features'] = arff_data['features'] + ['parent_x', 'parent_y',
                                 'previous_sibling_x', 'previous_sibling_y',
                                 'next_sibling_x', 'next_sibling_y']

        return X
示例#8
0
		    return Y_predict, loss_train

		elif self.updateMethod.lower == "sgd":
			if update_size == None:
				update_size = batch_size
			assert update_size <= batch_size, "Update size lager than batch size!"
			y_predict = np.dot(X, self.w)
			diff = y_predict - y
		    randind = np.random.randint(0,X.shape[0]-1, size=update_size)

		    # calculate the gradient
		    G = -np.dot(X[randind].T.reshape(-1, update_size), y[randind].reshape(update_size, -1))   
		    G += np.dot(X[randind].T.reshape(-1, update_size), X[randind].reshape(update_size, -1)).dot(self.w)
		    G = -G
		    # update the parameters
		    self.w += learning_rate * G  

		    y_predict_selected = np.dot(X[randind], self.w)  
		    loss_train = np.average(np.abs(y_predict_selected - y[randind])) 
		    
		    return y_predict, loss_train

	def predict(self, X):
		assert len(np.shape(X)) == 2, "Invalid input shape. The input must be 2d (batch, input_dim)"
		batch_size, input_dim = np.shape(X)
		assert self.input_dim == input_dim, "Unmatch input_dim."

		X = np.column_stack((X, np.ones((batch_size, 1))))
		y_predict = np.dot(X, self.w)
		return y_predict
    
示例#9
0
def wavFileToSound(wavFile):
    y, sr = librosa.load(wavFile)
    shiftedData = np.abs(librosa.stft(y))
    return shiftedData
示例#10
0
    def decode(self):
        display_result = ''
        filtedData = []
        current_length = 0
        current_data = []
        data = []
        flag = 0
        impulse_fft = []
        impulse_fft_tmp = []
        bin = []
        real = []
        self.decode_text.setPlainText(''.join(real))

        bandpass1 = 3000
        bandpass2 = 7000
        read_signal, fs = sf.read(FILENAME)

        wn1 = 2.0 * bandpass1 / sampling_rate
        wn2 = 2.0 * bandpass2 / sampling_rate
        b, a = signal.butter(8, [wn1, wn2], 'bandpass')  # 범위를 조금 더 넓게 해야할
        filtedData = signal.filtfilt(b, a, read_signal)  # data为要过滤的信号

        current_length = len(filtedData)
        current_data = filtedData
        while 1:
            once_check = 0
            corr = []
            corr_index = dict()

            print('finding preamble')
            print('current_data length', len(current_data))
            for i in range(current_length - len(preamble_y)):
                corr.append(
                    np.corrcoef(current_data[i:i + len(preamble_y)],
                                preamble_y)[0, 1])
                if once_check + 24000 == i and once_check != 0:
                    print('corr 찾는거 ')
                    break

                if corr[i] > 0.5:
                    if once_check == 0:
                        once_check = i
                        print('once_check', once_check)

                    corr_index[i] = corr[i]

            try:
                flag = max(corr_index.items(), key=operator.itemgetter(1))[0]
            except:
                print('decode 结束')
                break

            print(flag)
            data = current_data[flag + len(preamble_y):flag + len(preamble_y) +
                                60000]

            target_fre = 6000
            n = len(data)
            window = 600
            impulse_fft = np.zeros(n)
            for i in range(int(n - window)):
                y = np.fft.fft(data[i:i + int(window) - 1])
                y = np.abs(y)
                index_impulse = round(target_fre / sampling_rate * window)
                impulse_fft[i] = max(y[index_impulse - 2:index_impulse + 2])

            sliding_window = 5
            impulse_fft_tmp = impulse_fft
            for i in range(1 + sliding_window, n - sliding_window):
                impulse_fft_tmp[i] = np.mean(impulse_fft[i - sliding_window:i +
                                                         sliding_window])
            impulse_fft = impulse_fft_tmp

            #
            #
            # position_impulse = [];
            # half_window = 800;
            #
            #
            #
            # for i in range(n-half_window*2):
            #     if impulse_fft[i+half_window] > 90 and impulse_fft[i+half_window] == max(impulse_fft[i - half_window: i + half_window]):
            #         position_impulse.append(i)
            # message_bin = np.zeros(230400)
            # for i in range(len(position_impulse)):
            #     message_bin[math.ceil(position_impulse / 4800)] = 1
            # real_message_start = 1
            # last_one_index = 1
            # for i in range(3):
            #     if message_bin[i] == 1:
            #         last_one_index = i
            #
            # real_message_start = last_one_index + 1
            #
            # real_message_bin = message_bin[real_message_start:230400]
            #
            # curr_package_index = 0
            # curr_bin_index = 1
            # real_message_bin = np.matrix.H(real_message_bin)

            plus = 0
            adjust = 0
            count = 0
            while 1:
                decode_length = ''
                if adjust == 1:
                    plus += 0.1
                    print(plus)
                for i in range(8):

                    bin = np.mean(impulse_fft[i * 1200:(i + 1) * 1200])
                    bin += plus
                    print(bin)
                    if bin < 5:
                        decode_length = decode_length + '0'
                    else:
                        decode_length = decode_length + '1'

                print(decode_length)
                decode_payload_length = int(decode_length, 2)
                count += 1
                if count == 40:
                    break
                if decode_payload_length != 35:
                    adjust = 1
                else:
                    break

            if count == 40:
                decode_length = ''

                for i in range(8):
                    bin = np.mean(impulse_fft[i * 1200:(i + 1) * 1200])
                    print(bin)
                    if bin < 3:
                        decode_length = decode_length + '0'
                    else:
                        decode_length = decode_length + '1'

                print(decode_length)
                decode_payload_length = int(decode_length, 2)
                adjust = 0

                decode_payload = ''
                for i in range(decode_payload_length):
                    bin = np.mean(impulse_fft[(i + 8) * 1200:(i + 1 + 8) *
                                              1200])

                    if bin < 3:
                        decode_payload = decode_payload + '0'
                    else:
                        decode_payload = decode_payload + '1'
                    print(bin)
            else:
                decode_payload = ''
                for i in range(decode_payload_length):
                    bin = np.mean(impulse_fft[(i + 8) * 1200:(i + 1 + 8) *
                                              1200])

                    if adjust == 1:
                        bin += plus
                    if bin < 5:
                        decode_payload = decode_payload + '0'
                    else:
                        decode_payload = decode_payload + '1'
                    print(bin)

            print(decode_payload)
            while 1:
                if len(decode_payload) % 7 != 0:
                    decode_payload = decode_payload + '0'
                else:
                    break

            print(1200 * (int(decode_length, 2) + 8))
            current_data = current_data[1200 *
                                        (int(decode_length, 2) + 8 + 20) +
                                        flag:len(current_data)]
            current_length = len(current_data)
            display_result = display_result + decode_payload

        real = []
        for i in range(int(len(display_result) / 7)):
            real.append(decode_c(display_result[i * 7:(i + 1) * 7]))
        print(real)
        self.decode_text.setPlainText(''.join(real))

        print('result:', ''.join(real))
        global start
        cost_time = "time:" + str(time.time() - start) + '\n'
        decode_payload = decode_payload + '\n'

        file = open("result_translate.txt", 'w')
        file.write(cost_time)
        file.write(decode_payload)
        file.write(''.join(real))
        file.close()
def meanNonDiag(whitenedMatrix):

    whitenedCov = np.abs(np.cov(whitenedMatrix))
    sumNonDiag = np.sum(whitenedCov) - np.trace(whitenedCov)
    n = whitenedCov.shape[0]
    return sumNonDiag / (n * n - n)
示例#12
0
"""Pre Processing for audio
files as they are input.
For training data.
"""

#from __future__ import print_function
import librosa.display
import librosa
import np

# 1. Get the file path to the included audio example
data_folder = "C:\\Users\\Reece\\Documents\\GitHub\\ALD\\ALD\\src\\"
filename = data_folder + "50FrenchClean.mp3"

filename = librosa.util.example_audio_file()

# 2. Load the audio as a waveform `y`
#    Store the sampling rate as `sr`
y, sr = librosa.load(filename)

# 3. Run the default beat tracker
tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)

print('Estimated tempo: {:.2f} beats per minute'.format(tempo))

# 4. Convert the frame indices of beat events into timestamps
D = np.abs(librosa.stft(y))