def main():
# /!\ ADAPT PATHS /!\
parser = argparse.ArgumentParser()
parser.add_argument('--load_path_data',
default='%s/../recording/' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--load_path_model',
default='%s/../model/' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--save_path',
default='%s/../prediction/' %
os.path.dirname(os.path.abspath(__file__)))
# Arguments
args = parser.parse_args()
load_path_data = '/media/aditya/New Volume/Semester 5/EL EHD/Project/baby_cry_detection-master/pc_main/testing_samples/'
load_path_model = '/media/aditya/New Volume/Semester 5/EL EHD/Project/baby_cry_detection-master/Results/'
save_path = '/media/aditya/New Volume/Semester 5/EL EHD/Project/baby_cry_detection-master/Results/'
####################################################################################################################
# READ RAW SIGNAL
####################################################################################################################
# Read signal, write code for reading wav file into floating point numbers using librosa load function
# file_name = '/media/aditya/New Volume/Semester 5/EL EHD/Project/baby_cry_detection-master/pc_main/testing_samples/german-shephard-daniel_simon.ogg' # only one file in the folder (reading a stored file)
file_name = '/media/aditya/New Volume/Semester 5/EL EHD/Project/baby_cry_detection-master/rpi_methods/output.wav'
file_reader = Reader(os.path.join(load_path_data, file_name))
play_list = file_reader.read_audio_file()
####################################################################################################################
# iteration
####################################################################################################################
# iterate on play_list for feature engineering and prediction
####################################################################################################################
# FEATURE ENGINEERING
####################################################################################################################
# Feature extraction
engineer = FeatureEngineer()
play_list_processed = list()
print play_list
# signal must be audio time series, playlist must be list of that
for signal in play_list:
tmp = engineer.feature_engineer(
signal
) # for every audio file, 1 np_array containing features for windows,features are 2d
play_list_processed.append(tmp)
print play_list_processed
####################################################################################################################
# MAKE PREDICTION
####################################################################################################################
with open((os.path.join(load_path_model, 'model.pkl')), 'rb') as fp:
model = pickle.load(fp)
predictor = BabyCryPredictor(model)
predictions = list()
for signal in play_list_processed:
tmp = predictor.classify(signal)
predictions.append(tmp)
####################################################################################################################
# MAJORITY VOTE
####################################################################################################################
majority_voter = MajorityVoter(predictions)
majority_vote = majority_voter.vote()
####################################################################################################################
# SAVE
####################################################################################################################
# Save prediction result
with open(os.path.join(save_path, 'prediction.txt'), 'wb') as text_file:
text_file.write("{0}".format(majority_vote))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--load_path_data',
default='%s/../../external_input' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--load_path_model',
default='%s/../../output/model/' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--save_path',
default='%s/../../output/prediction/' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--file_name', default='signal_9s.wav')
parser.add_argument('--log_path',
default='%s/../' %
os.path.dirname(os.path.abspath(__file__)))
# Arguments
args = parser.parse_args()
load_path_data = args.load_path_data
load_path_model = args.load_path_model
file_name = args.file_name
save_path = args.save_path
log_path = args.log_path
####################################################################################################################
# Set up logging
####################################################################################################################
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %I:%M:%S %p',
filename=os.path.join(
log_path, 'logs_pc_methods_test_model.log'),
filemode='w',
level=logging.INFO)
####################################################################################################################
# READ RAW SIGNAL
####################################################################################################################
logging.info('Reading {0}'.format(file_name))
start = timeit.default_timer()
# Read signal (first 5 sec)
file_reader = Reader(os.path.join(load_path_data, file_name))
signal, _ = file_reader.read_audio_file()
stop = timeit.default_timer()
logging.info('Time taken for reading file: {0}'.format(stop - start))
####################################################################################################################
# FEATURE ENGINEERING
####################################################################################################################
logging.info('Starting feature engineering')
start = timeit.default_timer()
# Feature extraction
engineer = FeatureEngineer()
processed_signal = engineer.feature_engineer(signal)
# processed_signal.drop('label', axis=1, inplace=True)
stop = timeit.default_timer()
logging.info('Time taken for feature engineering: {0}'.format(stop -
start))
####################################################################################################################
# MAKE PREDICTION
####################################################################################################################
logging.info('Predicting...')
start = timeit.default_timer()
with open((os.path.join(load_path_model, 'model.pkl')), 'rb') as fp:
model = pickle.load(fp)
predictor = BabyCryPredictor(model)
prediction = predictor.classify(processed_signal)
stop = timeit.default_timer()
logging.info(
'Time taken for prediction: {0}. Is it a baby cry?? {1}'.format(
stop - start, prediction))
####################################################################################################################
# SAVE
####################################################################################################################
logging.info('Saving prediction...')
# Save prediction result
with open(os.path.join(save_path, 'prediction.txt'), 'wb') as text_file:
text_file.write("{0}".format(prediction))
logging.info('Saved! {0}'.format(os.path.join(save_path,
'prediction.txt')))
def main():
# /!\ ADAPT PATHS /!\
parser = argparse.ArgumentParser()
parser.add_argument('--load_path_data',
default='%s/../recording/' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--load_path_model',
default='%s/../model/' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--save_path',
default='%s/../prediction/' %
os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--file_name', default='noise.ogg')
# Arguments
args = parser.parse_args()
load_path_data = args.load_path_data
load_path_model = args.load_path_model
save_path = args.save_path
file_name = args.file_name
####################################################################################################################
# READ RAW SIGNAL
####################################################################################################################
# Read signal
# file_name = 'signal_9s.wav' # only one file in the folder
file_reader = Reader(os.path.join(load_path_data, file_name))
play_list = file_reader.read_audio_file()
####################################################################################################################
# iteration
####################################################################################################################
# iterate on play_list for feature engineering and prediction
####################################################################################################################
# FEATURE ENGINEERING
####################################################################################################################
# Feature extraction
engineer = FeatureEngineer()
play_list_processed = list()
for signal in play_list:
print(signal)
tmp = engineer.feature_engineer(signal)
play_list_processed.append(tmp)
####################################################################################################################
# MAKE PREDICTION
####################################################################################################################
with open((os.path.join(load_path_model, 'model.pkl')), 'rb') as fp:
model = pickle.load(fp)
predictor = BabyCryPredictor(model)
predictions = list()
for signal in play_list_processed:
tmp = predictor.classify(signal)
predictions.append(tmp)
print("predictions : " + str(predictions))
####################################################################################################################
# MAJORITY VOTE
####################################################################################################################
majority_voter = MajorityVoter(predictions)
majority_vote = majority_voter.vote()
print("Majority vote : " + str(majority_vote))
####################################################################################################################
# SAVE
####################################################################################################################
# # Save prediction result
# with open(os.path.join(save_path, 'prediction.txt'), 'wb') as text_file:
# text_file.write("{0}".format(majority_vote))
# Save prediction result
with open(os.path.join(save_path, 'prediction.txt'), 'wb') as text_file:
text_file.write(bytes(majority_vote))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--load_path_data',
default=os.path.dirname(os.path.abspath(__file__)))
parser.add_argument('--load_path_model',
default='{}/../../../output/model/'.format(os.path.dirname(os.path.abspath(__file__))))
parser.add_argument('--save_path',
default='{}/../../../output/prediction/'.format(os.path.dirname(os.path.abspath(__file__))))
parser.add_argument('--file_name', default=cryfile)
parser.add_argument('--log_path',
default='{}/'.format(os.path.dirname(os.path.abspath(__file__))))
# Arguments
args = parser.parse_args()
load_path_data = os.path.normpath(args.load_path_data)
load_path_model = os.path.normpath(args.load_path_model)
file_name = args.file_name
save_path = os.path.normpath(args.save_path)
log_path = os.path.normpath(args.log_path)
# Set up logging
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %I:%M:%S %p',
filename=os.path.join(log_path, 'logs_prediction_test_test_model.log'),
filemode='w',
level=logging.INFO)
# READ RAW SIGNAL
logging.info('Reading {0}'.format(file_name))
start = timeit.default_timer()
# Read signal (first 5 sec)
file_reader = Reader(os.path.join(load_path_data, file_name))
play_list = file_reader.read_audio_file()
stop = timeit.default_timer()
logging.info('Time taken for reading file: {0}'.format(stop - start))
# FEATURE ENGINEERING
logging.info('Starting feature engineering')
start = timeit.default_timer()
# Feature extraction
engineer = FeatureEngineer()
play_list_processed = list()
for signal in play_list:
tmp = engineer.feature_engineer(signal)
play_list_processed.append(tmp)
stop = timeit.default_timer()
logging.info('Time taken for feature engineering: {0}'.format(stop - start))
# MAKE PREDICTION
logging.info('Predicting...')
start = timeit.default_timer()
# https://stackoverflow.com/questions/41146759/check-sklearn-version-before-loading-model-using-joblib
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=UserWarning)
#with open((os.path.join(load_path_model, 'model.pkl')), 'rb') as fp:
with open(('model.pkl'), 'rb') as fp:
model = pickle.load(fp
,encoding='latin1'
)
#print(model)
#model.encoding = 'UTF-8'
predictor = BabyCryPredictor(model)
predictions = list()
#print(signal)
for signal in play_list_processed:
tmp = predictor.classify(signal)
predictions.append(tmp)
# MAJORITY VOTE
majority_voter = MajorityVoter(predictions)
majority_vote = majority_voter.vote()
print(majority_vote)
answer = majority_vote
stop = timeit.default_timer()
logging.info('Time taken for prediction: {0}. Is it a baby cry?? {1}'.format(stop - start, majority_vote))
# SAVE
logging.info('Saving prediction...')
# Save prediction result
#with open(os.path.join(save_path, 'prediction.txt'), 'wb') as text_file:
'''
with open('prediction.txt', 'wb') as text_file:
text_file.write("{}".format(majority_vote))
logging.info('Saved! {}'.format(os.path.join(save_path, 'prediction.txt')))
'''
"""
if answer is 1:
msg = " 아이가 울고있어요."
else:
msg = "주변에 소음이 있어요."
"""
return answer