def remove_silence(audio_path, out_directory):
"""
Segments audio removing all segments of silence
:return: A list of lists of times in seconds. Each pair of times indicate start and end time of segments with
noise
"""
[fs, x] = aIO.readAudioFile(audio_path)
segments = aS.silenceRemoval(x,
fs,
0.05,
0.02,
smoothWindow=1.0,
weight=0.3,
plot=False)
dub_audio = AudioSegment.from_wav(audio_path)
counter = 1
for segment in segments:
t1 = segment[0] * 1000
t2 = segment[1] * 1000
audio_segment = dub_audio[t1:t2]
format_name = "{}/{}audio_segment.wav".format(out_directory, counter)
audio_segment.export(format_name, format="wav")
counter += 1
return segments
def silenceRemovalWrapper(inputFile, smoothingWindow, weight):
if not os.path.isfile(inputFile):
raise Exception("Input audio file not found!")
[fs, x] = audioBasicIO.readAudioFile(inputFile)
segmentLimits = aS.silenceRemoval(x, fs, 0.05, 0.05,
smoothingWindow, weight, True)
for i, s in enumerate(segmentLimits):
strOut = "{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], s[0], s[1])
wavfile.write(strOut, fs, x[int(fs * s[0]):int(fs * s[1])])
def silenceRemovalWrapper(inputFile, smoothingWindow, weight):
if not os.path.isfile(inputFile):
raise Exception("Input audio file not found!")
[fs, x] = audioBasicIO.readAudioFile(inputFile)
segmentLimits = aS.silenceRemoval(x, fs, 0.05, 0.05,
smoothingWindow, weight, True)
for i, s in enumerate(segmentLimits):
strOut = "{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], s[0], s[1])
wavfile.write(strOut, fs, x[int(fs * s[0]):int(fs * s[1])])
def remove_silence(filename, out_dir, smoothing=1.0, weight=0.3, plot=False):
"""
A function that implements pyAudioAnalysis' silence extraction module
and creates wav files of the participant specific portions of audio. The
smoothing and weight parameters were tuned for the AVEC 2016 dataset.
Parameters
----------
filename : filepath
path to the input wav file
out_dir : filepath
path to the desired directory (where a participant folder will
be created containing a 'PXXX_no_silence.wav' file)
smoothing : float
tunable parameter to compensate for sparseness of recordings
weight : float
probability threshold for silence removal used in SVM
plot : bool
plots SVM probabilities of silence (used in tuning)
Returns
-------
A folder for each participant containing a single wav file
(named 'PXXX_no_silence.wav') with the vast majority of silence
and virtual interviewer speech removed. Feature extraction is
performed on these segmented wav files.
"""
partic_id = 'P' + filename.split('/')[-1].split('_')[0] # PXXX
if is_segmentable(partic_id):
# create participant directory for segmented wav files
participant_dir = os.path.join(out_dir, partic_id)
if not os.path.exists(participant_dir):
os.makedirs(participant_dir)
os.chdir(participant_dir)
[Fs, x] = aIO.readAudioFile(filename)
segments = aS.silenceRemoval(x,
Fs,
0.020,
0.020,
smoothWindow=smoothing,
Weight=weight,
plot=plot)
for s in segments:
seg_name = "{:s}_{:.2f}-{:.2f}.wav".format(partic_id, s[0], s[1])
wavfile.write(seg_name, Fs, x[int(Fs * s[0]):int(Fs * s[1])])
# concatenate segmented wave files within participant directory
concatenate_segments(participant_dir, partic_id)
def event_extraction(classname, path=os.getcwd()):
os.chdir(path)
for inputFile in glob.glob("*.wav"):
if not os.path.isfile(inputFile):
raise Exception("Input audio file not found!")
[Fs, x] = audioBasicIO.readAudioFile(inputFile)
segmentLimits = aS.silenceRemoval(x, Fs, 0.05, 0.05, 1.0, 0.3, False)
for i, s in enumerate(segmentLimits):
if not os.path.exists(classname):
os.makedirs(classname)
strOut = os.path.join(
path, classname,
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], s[0],
s[1]))
wavfile.write(strOut, Fs, x[int(Fs * s[0]):int(Fs * s[1])])
output_path = path + classname
return output_path
def clean_response_from_user(filename):
#This method takes in the original question and answer recording and saves just the response
from pyAudioAnalysis import audioBasicIO as aIO
from pyAudioAnalysis import audioSegmentation as aS
import scipy.io.wavfile as wavfile
#filename="data/practice_run1.wav"
[Fs, x] = aIO.readAudioFile(filename)
segments = aS.silenceRemoval(x,
Fs,
0.020,
0.020,
smoothWindow=0.2,
Weight=0.65,
plot=False)
segments = segments[0]
strOut = "user_response.wav"
#("{0:s}_" + str(i) + ".wav").format(filename[0:-4], s[0], s[1])
wavfile.write(strOut, Fs, x[int(Fs * segments[0]):int(Fs * segments[1])])
def segment_audio(inputFile, smoothingWindow, weight):
print 'entered segment_audio function'
[Fs, x] = audioBasicIO.readAudioFile(inputFile)
dir, inputFile = os.path.split(inputFile)
create_subdirectory(dir, 'noise')
create_subdirectory(dir, 'activity')
create_subdirectory(dir, 'clean')
segmentLimits = aS.silenceRemoval(x, Fs, smoothingWindow / 10.0,
smoothingWindow / 10.0, smoothingWindow,
weight, False) # get onsets
prev_end = 0
activity_files = []
noise_files = []
for i, s in enumerate(segmentLimits):
strOut = os.path.join(
dir, "noise",
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], prev_end,
s[0]))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):int(Fs * s[0])])
noise_files.append(strOut)
strOut = os.path.join(
dir, "activity",
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], s[0], s[1]))
wavfile.write(strOut, Fs, x[int(Fs * s[0]):int(Fs * s[1])])
activity_files.append(strOut)
prev_end = s[1]
strOut = os.path.join(
dir, "noise",
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], prev_end,
len(x) / Fs))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):len(x) / Fs])
noise_files.append(strOut)
activity_out = os.path.join(dir, "activity", inputFile)
noise_out = os.path.join(dir, "noise", inputFile)
recombine_wavfiles(noise_files, noise_out)
recombine_wavfiles(activity_files, activity_out)
def infer_file(model, fname):
tone = find_peak(fname)
[Fs, x] = wavfile.read(fname)
segments = silenceRemoval(x, Fs, 0.25, 0.05, 0.2, 0.2, True)
for start, stop in segments:
print("*" * 80, f"start:{start}, stop:{stop} dur:{stop-start}")
o, dur = process_audio_file2(fname, start, stop, tone)
start_time = datetime.datetime.now()
iname, recognized, probability = infer_image(model, o[0:256])
stop_time = datetime.datetime.now()
if True: #probability[0] > 0.00005:
print(f'File:{iname}')
print('Recognized:', '"' + recognized[0] + '"')
print('Probability:', probability[0])
print('Duration:{}'.format(stop_time - start_time))
return
sample = 4.0
start = 0.
tone = find_peak(fname)
o, dur = process_audio_file(fname, start, sample, tone)
while start < (dur - sample):
print(start, dur)
im = o[0::1].reshape(1, 256)
im = im * 256.
img = cv2.resize(im, model.imgSize, interpolation=cv2.INTER_AREA)
cv2.imwrite(f'dummy{start}.png', img)
img = cv2.transpose(img)
batch = Batch(None, [img])
start_time = datetime.datetime.now()
(recognized, probability) = model.inferBatch(batch, True)
stop_time = datetime.datetime.now()
if probability[0] > 0.00005:
print('Recognized:', '"' + recognized[0] + '"')
print('Probability:', probability[0])
print('Duration:{}'.format(stop_time - start_time))
start += 1. / 1
o, dur = process_audio_file(fname, start, sample, tone)
class noiseCleaner:
def __init__(self, smoothingWindow=0.4, weight=0.4, sensitivity=0.4, debug=True,
verbose=False, num_threads=mp.cpu_count()):
self.smoothingWindow = smoothingWindow
self.weight = weight
self.sensitivity = sensitivity
self.debug = debug
self.verbose = verbose
self.num_threads = num_threads
def noise_removal(self, inputFile):
smoothingWindow = self.smoothingWindow
weight = self.weight
sensitivity = self.sensitivity
debug = self.debug
verbose = self.verbose
if verbose:
print inputFile
if not os.path.isfile(inputFile):
raise Exception(inputFile + " not found!")
[Fs, x] = audioBasicIO.readAudioFile(inputFile) # read audio signal
dir, inputFile = os.path.split(inputFile)
try:
create_subdirectory(dir, 'noise')
create_subdirectory(dir, 'activity')
root, current_sub_dir = os.path.split(dir)
clean_dir = '_'.join([current_sub_dir, 'clean'])
create_subdirectory(dir, clean_dir)
except OSError, e:
if e.errno != 17:
raise
# time.sleep might help here
pass
segmentLimits = aS.silenceRemoval(x, Fs, 0.05, 0.05, smoothingWindow, weight, False) # get onsets
prev_end = 0
activity_files = []
noise_files = []
for i, s in enumerate(segmentLimits):
strOut = os.path.join(dir, "noise", "{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], prev_end, s[0]))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):int(Fs * s[0])])
noise_files.append(strOut)
strOut = os.path.join(dir, "activity", "{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], s[0], s[1]))
wavfile.write(strOut, Fs, x[int(Fs * s[0]):int(Fs * s[1])])
activity_files.append(strOut)
prev_end = s[1]
strOut = os.path.join(dir, "noise", "{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], prev_end, len(x) / Fs))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):len(x) / Fs])
noise_files.append(strOut)
activity_out = os.path.join(dir, "activity", inputFile)
noise_out = os.path.join(dir, "noise", inputFile)
recombine_wavfiles(noise_files, noise_out)
recombine_wavfiles(activity_files, activity_out)
# try:
tfs = sox.Transformer()
noise_profile_path = '.'.join([noise_out, 'prof'])
tfs.noiseprof(noise_out, noise_profile_path)
tfs.build(noise_out, '-n')
tfs.clear_effects()
tfs.noisered(noise_profile_path, amount=sensitivity)
clean_out = os.path.join(dir, clean_dir, inputFile)
tfs.build(activity_out, clean_out)
# except:
# original_file = os.path.join(dir, inputFile)
# sys.stderr.write("Sox error in noise reduction of file: %s.\n" % original_file)
# clean_out = os.path.join(dir, clean_dir, inputFile)
# shutil.copyfile(original_file, clean_out)
if not debug:
shutil.rmtree(os.path.join(dir, "noise"))
shutil.rmtree(os.path.join(dir, "activity"))
return clean_out
def main(argv):
if argv[1] == "-shortTerm":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("snakehit.wav")
duration = x.shape[0] / float(Fs)
t1 = time.clock()
F = audioFeatureExtraction.stFeatureExtraction(
x, Fs, 0.050 * Fs, 0.050 * Fs)
t2 = time.clock()
perTime1 = duration / (t2 - t1)
print "short-term feature extraction: {0:.1f} x realtime".format(
perTime1)
elif argv[1] == "-classifyFile":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("snakehit.wav")
duration = x.shape[0] / float(Fs)
t1 = time.clock()
aT.fileClassification("snakehit.wav", "svmSM", "svm")
t2 = time.clock()
perTime1 = duration / (t2 - t1)
print "Mid-term feature extraction + classification \t {0:.1f} x realtime".format(
perTime1)
elif argv[1] == "-mtClassify":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("snakehit.wav")
duration = x.shape[0] / float(Fs)
t1 = time.clock()
[flagsInd, classesAll,
acc] = aS.mtFileClassification("snakehit.wav", "svmSM", "svm",
False, '')
t2 = time.clock()
perTime1 = duration / (t2 - t1)
print "Fix-sized classification - segmentation \t {0:.1f} x realtime".format(
perTime1)
elif argv[1] == "-hmmSegmentation":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("snakehit.wav")
duration = x.shape[0] / float(Fs)
t1 = time.clock()
aS.hmmSegmentation('snakehit.wav', 'hmmRadioSM', False, '')
t2 = time.clock()
perTime1 = duration / (t2 - t1)
print "HMM-based classification - segmentation \t {0:.1f} x realtime".format(
perTime1)
elif argv[1] == "-silenceRemoval":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("snakehit.wav")
duration = x.shape[0] / float(Fs)
t1 = time.clock()
[Fs, x] = audioBasicIO.readAudioFile("snakehit.wav")
segments = aS.silenceRemoval(x,
Fs,
0.050,
0.050,
smoothWindow=1.0,
Weight=0.3,
plot=False)
t2 = time.clock()
perTime1 = duration / (t2 - t1)
print "Silence removal \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-thumbnailing":
for i in range(nExp):
[Fs1, x1] = audioBasicIO.readAudioFile("scottish.wav")
duration1 = x1.shape[0] / float(Fs1)
t1 = time.clock()
[A1, A2, B1, B2,
Smatrix] = aS.musicThumbnailing(x1, Fs1, 1.0, 1.0,
15.0) # find thumbnail endpoints
t2 = time.clock()
perTime1 = duration1 / (t2 - t1)
print "Thumbnail \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-diarization-noLDA":
for i in range(nExp):
[Fs1, x1] = audioBasicIO.readAudioFile("snakehit.wav")
duration1 = x1.shape[0] / float(Fs1)
t1 = time.clock()
aS.speakerDiarization("snakehit.wav", 4, LDAdim=0, PLOT=False)
t2 = time.clock()
perTime1 = duration1 / (t2 - t1)
print "Diarization \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-diarization-LDA":
for i in range(nExp):
[Fs1, x1] = audioBasicIO.readAudioFile("snakehit.wav")
duration1 = x1.shape[0] / float(Fs1)
t1 = time.clock()
aS.speakerDiarization("snakehit.wav", 4, PLOT=False)
t2 = time.clock()
perTime1 = duration1 / (t2 - t1)
print "Diarization \t {0:.1f} x realtime".format(perTime1)
from pyAudioAnalysis import audioSegmentation as aS
import re
import soundfile as sf
import subprocess
import os
##python audioAnalysis.py silenceRemoval -i test/amlo_mix.wav --smoothing 0.7 --weight 0.9
# #
direc = "test/"
wav_file = "amlo_mix4.wav"
[Fs, x] = aIO.readAudioFile(direc + wav_file)
segments = aS.silenceRemoval(x,
Fs,
0.020,
0.020,
smoothWindow=.7,
Weight=.9,
plot=True)
newpath = direc + wav_file + "segs"
original = direc + wav_file
f = sf.SoundFile(direc + wav_file)
frames = len(f)
sample_rate = float(f.samplerate)
print(sample_rate)
time = frames / float(sample_rate)
print time
#
#
def main(argv):
if argv[1] == "-shortTerm":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("diarizationExample.wav");
duration = x.shape[0] / float(Fs)
t1 = time.clock()
F = audioFeatureExtraction.stFeatureExtraction(x, Fs, 0.050*Fs, 0.050*Fs);
t2 = time.clock()
perTime1 = duration / (t2-t1); print "short-term feature extraction: {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-classifyFile":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("diarizationExample.wav");
duration = x.shape[0] / float(Fs)
t1 = time.clock()
aT.fileClassification("diarizationExample.wav", "svmSM","svm")
t2 = time.clock()
perTime1 = duration / (t2-t1); print "Mid-term feature extraction + classification \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-mtClassify":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("diarizationExample.wav");
duration = x.shape[0] / float(Fs)
t1 = time.clock()
[flagsInd, classesAll, acc] = aS.mtFileClassification("diarizationExample.wav", "svmSM", "svm", False, '')
t2 = time.clock()
perTime1 = duration / (t2-t1); print "Fix-sized classification - segmentation \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-hmmSegmentation":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("diarizationExample.wav");
duration = x.shape[0] / float(Fs)
t1 = time.clock()
aS.hmmSegmentation('diarizationExample.wav', 'hmmRadioSM', False, '')
t2 = time.clock()
perTime1 = duration / (t2-t1); print "HMM-based classification - segmentation \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-silenceRemoval":
for i in range(nExp):
[Fs, x] = audioBasicIO.readAudioFile("diarizationExample.wav");
duration = x.shape[0] / float(Fs)
t1 = time.clock()
[Fs, x] = audioBasicIO.readAudioFile("diarizationExample.wav");
segments = aS.silenceRemoval(x, Fs, 0.050, 0.050, smoothWindow = 1.0, Weight = 0.3, plot = False)
t2 = time.clock()
perTime1 = duration / (t2-t1); print "Silence removal \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-thumbnailing":
for i in range(nExp):
[Fs1, x1] = audioBasicIO.readAudioFile("scottish.wav")
duration1 = x1.shape[0] / float(Fs1)
t1 = time.clock()
[A1, A2, B1, B2, Smatrix] = aS.musicThumbnailing(x1, Fs1, 1.0, 1.0, 15.0) # find thumbnail endpoints
t2 = time.clock()
perTime1 = duration1 / (t2-t1); print "Thumbnail \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-diarization-noLDA":
for i in range(nExp):
[Fs1, x1] = audioBasicIO.readAudioFile("diarizationExample.wav")
duration1 = x1.shape[0] / float(Fs1)
t1 = time.clock()
aS.speakerDiarization("diarizationExample.wav", 4, LDAdim = 0, PLOT = False)
t2 = time.clock()
perTime1 = duration1 / (t2-t1); print "Diarization \t {0:.1f} x realtime".format(perTime1)
elif argv[1] == "-diarization-LDA":
for i in range(nExp):
[Fs1, x1] = audioBasicIO.readAudioFile("diarizationExample.wav")
duration1 = x1.shape[0] / float(Fs1)
t1 = time.clock()
aS.speakerDiarization("diarizationExample.wav", 4, PLOT = False)
t2 = time.clock()
perTime1 = duration1 / (t2-t1); print "Diarization \t {0:.1f} x realtime".format(perTime1)
from pyAudioAnalysis import audioSilencePeriods as aSP
from pyAudioAnalysis import audioBasicIO as aIO
from pyAudioAnalysis import audioSegmentation as aS
[Fs, x] = aIO.readAudioFile("custom/audio/output.wav")
segments = aSP.silenceCounter(x, Fs, 0.020, 0.020,
smoothWindow=1.0, weight=0.3, plot=True)
silences = aS.silenceRemoval(x, Fs, 0.020, 0.020,
smoothWindow=1.0, weight=0.3, plot=True)
print(silences)
def extractAudio():
# Declarations
global userid, starttime, endtime, myPath, numbPauses, loudness, dur, madmax, maxDBFS, MPA, numOfFtrs, phoneCallFtrFinal, wavo, jsonFeatures, nf
userid = ""
starttime = ""
endtime = ""
myPath = ""
numbPauses = 0
loudness = 0
nf = 0
dur = 0
madmax = 0
maxDBFS = 0
MPA = 0
numOfFtrs = 0
wavo = ""
jsonFeatures = {}
phoneCallFtrFinal = pd.DataFrame()
# getting the parameters
if request.method == 'POST':
userid = request.args.get('userid')
#userid = request.form['userid']
print " Android must Have invoked this"
# Ftp connection
FtpHostName = "****************"
FtpUser = "******"
FtpPassword = "******"
ftp = FTP(FtpHostName)
ftp.login(FtpUser, FtpPassword)
path = "************************"
########################################
########################################
# Phone calls processing and features extraction
#########################################
#########################################
#########################################
# SQL queries
curWAV, conn = connection()
reqWAV = "SELECT * FROM files AS f WHERE f.uid = %s and f.type = 'WAV' "
curWAV.execute(reqWAV, userid)
WAVfiles = curWAV.fetchall()
wavs_dict = []
for wavf in WAVfiles:
wavf_dict = {
'Id': wavf[0],
'filepath': wavf[1],
'type': wavf[2],
'createdat': wavf[3],
'uid': wavf[4]
}
wavs_dict.append(wavf_dict)
#print wavs_dict.__len__()
print len(WAVfiles)
ind = 0
patho = "/home/ahmed/Desktop/flaskTherapio/"
for wavfile in WAVfiles:
ind += 1
print "checking database for the " + str(ind) + " time"
dirPath = wavfile[1][1:17]
wavName = wavfile[1][17:]
wavdate = wavfile[3][1:10]
#print dirPath
print wavName
print wavdate
ftp.cwd("/" + dirPath)
print "done changing directory"
audiofilematch = '*.wav'
cc = 0
for filename in ftp.nlst(
audiofilematch): # Loop - looking for WAV files
cc += 1
print "checking FTP for the " + str(cc) + " time"
print "comparing " + wavName + " and " + filename
print wavName == filename
fhandle = open(filename, 'wb')
print 'Getting ' + filename
os.chdir("/home/ahmed/Desktop/flaskTherapio/")
ftp.retrbinary('RETR ' + filename, fhandle.write)
print "stored"
fhandle.close()
if filename == wavName:
print " just do this shit here"
sound = AudioSegment.from_file(patho + filename)
sound.export(patho + "PhoneCallsFtr/" + filename + ".wav",
format="wav")
loudness = sound.rms
#number of Frames
nf = sound.frame_count()
# Value of loudness
loudness = sound.rms
#duration
dur = sound.duration_seconds
#max
madmax = sound.max
#max possible amplitude
MPA = sound.max_possible_amplitude
#max dbfs
maxDBFS = sound.max_dBFS
samplewidth = sound.sample_width
today = datetime.datetime.today().strftime("%m/%d/%Y")
blahblah = patho + "PhoneCallsFtr/" + filename + ".wav"
print "Blah blah path : ======> " + blahblah
[Fs, x] = audioBasicIO.readAudioFile(blahblah)
#silence removal ---- into segments
segments = aS.silenceRemoval(x,
Fs,
0.030,
0.030,
smoothWindow=0.3,
Weight=0.6,
plot=True)
numbPauses = len(segments) - 1
if numbPauses:
error = False
else:
error = True
print "num pauses : " + str(numbPauses)
# SELECT * FROM `phoneCallFeatures` WHERE (`created_at` BETWEEN 60 AND 1500) AND (uid = '5795028d168257.04609170')
# SQL query to insert phone call features to DB
insertFtrReq = """INSERT INTO phoneCallFeatures
(uid,
npause,
loudness,
maxA,
created_at)
VALUES (%s,
%s,
%s,
%s,
%s)""", (userid,
numbPauses,
loudness,
madmax, wavdate)
curInsertFtr, conn = connection()
curInsertFtr.execute(*insertFtrReq)
conn.commit()
# short term features extraction
fw = audioFeatureExtraction.stFeatureExtraction(
x, Fs, 0.1 * Fs, 0.1 * Fs)
print fw
# Mid term feature extraction
#F1 = audioFeatureExtraction.mtFeatureExtraction(x, Fs, 0.050*Fs, 0.050*Fs,0.050*Fs, 0.050*Fs)
mypath = "/home/ahmed/Desktop/flaskTherapio/PhoneCallsFtr/"
if not os.path.isdir(mypath):
os.makedirs(mypath)
numpy.savetxt(mypath + wavName + "_AllStFtrs.csv",
fw,
delimiter=",")
#numpy.savetxt("00_AllMidFtrs.csv", F1, delimiter=",")
# read features in a data frame
phoneCallFtrPrime = pd.read_csv(mypath + wavName +
"_AllStFtrs.csv")
COLUMNS = []
for i in range(0, len(phoneCallFtrPrime.columns)):
COLUMNS.append('Frame' + str(i + 1))
COLUMNS.append('label')
phoneCallFtrFinal = pd.read_csv(mypath + wavName +
"_AllStFtrs.csv",
header=None,
names=COLUMNS)
numOfFtrs = len(phoneCallFtrFinal["label"])
phoneCallFtrFinal.label = phoneCallFtrFinal.label.astype(
float).fillna(0)
# phoneCallFtrFinal.label = phoneCallFtrFinal.label.astype(int).fillna(0)
for j in range(0, numOfFtrs):
phoneCallFtrFinal.iloc[j]['label'] = 0
#jsonFeatures = phoneCallFtrFinal.reset_index().to_json(orient='index')
#jsonFeatures = phoneCallFtrFinal.to_json(orient=None)
display(phoneCallFtrFinal.head())
#print "JSON Features of every audio ----------------------------------------------"
#print jsonFeatures
print "this script has been called and data has been handled"
return jsonify({'USER ID': userid}), 201
class noiseCleaner:
def __init__(self,
smoothingWindow=0.4,
weight=0.4,
sensitivity=0.4,
debug=True,
verbose=False,
num_threads=mp.cpu_count()):
self.smoothingWindow = smoothingWindow
self.weight = weight
self.sensitivity = sensitivity
self.debug = debug
self.verbose = verbose
self.num_threads = num_threads
#This function performs noise removal for a single file
#in some cases the process will fail, either because the file is too short or because activity is constant and therfore a noise profile cannot be generated
#in this case the function will simply make a copy of the original file into the "clean" folder to feed to the classifier
def noise_removal(self, inputFile):
smoothingWindow = self.smoothingWindow
weight = self.weight
sensitivity = self.sensitivity
debug = self.debug
verbose = self.verbose
if verbose:
print inputFile
if not os.path.isfile(inputFile):
raise Exception(inputFile + " not found!")
[Fs, x] = audioBasicIO.readAudioFile(inputFile) # read audio signal
dir, inputFile = os.path.split(inputFile)
try:
create_subdirectory(dir, 'noise')
create_subdirectory(dir, 'activity')
root, current_sub_dir = os.path.split(dir)
clean_dir = '_'.join([current_sub_dir, 'clean'])
create_subdirectory(dir, clean_dir)
except OSError, e:
if e.errno != 17:
raise
# time.sleep might help here
pass
try:
segmentLimits = aS.silenceRemoval(x, Fs, smoothingWindow / 10.0,
smoothingWindow / 10.0,
smoothingWindow, weight,
False) # get onsets
prev_end = 0
activity_files = []
noise_files = []
for i, s in enumerate(segmentLimits):
strOut = os.path.join(
dir, "noise",
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4],
prev_end, s[0]))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):int(Fs * s[0])])
noise_files.append(strOut)
strOut = os.path.join(
dir, "activity",
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], s[0],
s[1]))
wavfile.write(strOut, Fs, x[int(Fs * s[0]):int(Fs * s[1])])
activity_files.append(strOut)
prev_end = s[1]
strOut = os.path.join(
dir, "noise",
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], prev_end,
len(x) / Fs))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):len(x) / Fs])
noise_files.append(strOut)
activity_out = os.path.join(dir, "activity", inputFile)
noise_out = os.path.join(dir, "noise", inputFile)
recombine_wavfiles(noise_files, noise_out)
recombine_wavfiles(activity_files, activity_out)
tfs = sox.Transformer()
noise_profile_path = '.'.join([noise_out, 'prof'])
tfs.noiseprof(noise_out, noise_profile_path)
tfs.build(noise_out, '-n')
tfs.clear_effects()
tfs.noisered(noise_profile_path, amount=sensitivity)
clean_out = os.path.join(dir, clean_dir, inputFile)
tfs.build(activity_out, clean_out)
except:
original_file = os.path.join(dir, inputFile)
sys.stderr.write("Sox error in noise reduction of file: %s.\n" %
original_file)
clean_out = os.path.join(dir, clean_dir, inputFile)
shutil.copyfile(original_file, clean_out)
with open(os.path.join(dir, clean_dir, 'NR_fail_record.log'),
'a') as fail_record:
fail_record.write('%s\n' % original_file)
if not debug:
shutil.rmtree(os.path.join(dir, "noise"))
shutil.rmtree(os.path.join(dir, "activity"))
return clean_out
#Performs noise_removal for an entire directory recursively, meaning that all wav files in all subdirectories will be processed
# def noise_removal_dir(self, rootdir):
#
# num_threads = self.num_threads
#
# if not os.path.exists(rootdir):
# raise Exception(rootdir + " not found!")
#
# for root, dirs, files in os.walk(rootdir):
# parent, folder_name = os.path.split(root)
# if folder_name == 'activity' or folder_name == 'noise' or '_clean' in folder_name:
# shutil.rmtree(root)
# num_samples_processed = 0
# wav_files = []
# for root, dirs, files in os.walk(rootdir):
# for file in files:
# if file.endswith('.wav') or file.endswith('.WAV'):
# wav_files.append(os.path.join(root, file))
# num_samples_processed += 1
# if not num_threads:
# self.noise_removal(os.path.join(root,file))
#
# print "Now beginning preprocessing for: ", num_samples_processed, " samples."
#
# try:
# if num_threads:
# pros = Pool(num_threads)
# pros.map(self.noise_removal, wav_files)
# except cPickle.PicklingError:
# for wfile in wav_files:
# self.noise_removal(wfile)
#
# print "Preprocessing complete!\n"
from pyAudioAnalysis import audioBasicIO as aIO
from pyAudioAnalysis import audioSegmentation as aS
[Fs, x] = aIO.readAudioFile("keys.wav")
segments = aS.silenceRemoval(x,
Fs,
0.010,
0.020,
smoothWindow=0.02,
Weight=0.3,
plot=True)
import os
from pyAudioAnalysis import audioBasicIO as aIO
from pyAudioAnalysis import audioSegmentation as aS
dir_path = os.path.dirname(os.path.realpath(__file__))
file_path = os.path.join(dir_path, "doremi.wav")
print "Test silence removal on %s..." % file_path
[Fs, x] = aIO.readAudioFile(file_path)
segments = aS.silenceRemoval(x,
Fs,
0.020,
0.020,
smoothWindow=1.0,
Weight=0.3,
plot=False)
print "Successfully ran silence removal!"
print segments
def dashboard(userid):
# Declarations
global starttime, endtime, myPath, numbPauses, loudness, dur, madmax, maxDBFS, MPA, numOfFtrs, phoneCallFtrFinal, wavo, jsonFeatures, nf
starttime = ""
endtime = ""
myPath = ""
numbPauses = 0
loudness = 0
nf = 0
dur = 0
madmax = 0
maxDBFS = 0
MPA = 0
numOfFtrs = 0
wavo = ""
jsonFeatures = {}
phoneCallFtrFinal = pd.DataFrame()
# Ftp connection
FtpHostName = "**********************"
FtpUser = "******"
FtpPassword = "******"
ftp = FTP(FtpHostName)
ftp.login(FtpUser, FtpPassword)
path = "****************************"
# forms
form = DateForm()
if form.validate_on_submit():
starttime = form.dt.data.strftime('%x')
#endtime = form.dt.data.strftime('%x')
########################################
########################################
# Accelerometer CSV data manipulation and features extraction
#########################################
#########################################
#########################################
# SQL queries
curCSV, conn = connection()
reqCSV = "SELECT * FROM files AS f WHERE f.uid = %s and f.type = 'CSV' "
curCSV.execute(reqCSV, userid)
CSVfiles = curCSV.fetchall()
def magnitude(activity):
x2 = activity['xAxis'] * activity['xAxis']
y2 = activity['yAxis'] * activity['yAxis']
z2 = activity['zAxis'] * activity['zAxis']
m2 = x2 + y2 + z2
m = m2.apply(lambda x: math.sqrt(x))
return m
def windows(df, size=100):
start = 0
while start < df.count():
yield start, start + size
start += (size / 2)
def jitter(axis, start, end):
j = float(0)
for i in xrange(start, min(end, axis.count())):
if start != 0:
j += abs(axis[i] - axis[i - 1])
return j / (end - start)
def mean_crossing_rate(axis, start, end):
cr = 0
m = axis.mean()
for i in xrange(start, min(end, axis.count())):
if start != 0:
p = axis[i - 1] > m
c = axis[i] > m
if p != c:
cr += 1
return float(cr) / (end - start - 1)
def window_summary(axis, start, end):
acf = stattools.acf(axis[start:end])
acv = stattools.acovf(axis[start:end])
sqd_error = (axis[start:end] - axis[start:end].mean())**2
return [
jitter(axis, start, end),
mean_crossing_rate(axis, start, end),
axis[start:end].mean(),
axis[start:end].std(),
axis[start:end].var(),
axis[start:end].min(),
axis[start:end].max(),
acf.mean(), # mean auto correlation
acf.std(), # standard deviation auto correlation
acv.mean(), # mean auto covariance
acv.std(), # standard deviation auto covariance
skew(axis[start:end]),
kurtosis(axis[start:end]),
math.sqrt(sqd_error.mean())
]
def features(activity):
for (start, end) in windows(activity['timestamp']):
features = []
for axis in ['xAxis', 'yAxis', 'zAxis', 'magnitude']:
features += window_summary(activity[axis], start, end)
yield features
COLUMNS = ['timestamp', 'xAxis', 'yAxis', 'zAxis']
features_dict = []
for csvfile in CSVfiles:
Activity = pd.read_csv(path + csvfile[1], header=None,
names=COLUMNS)[:3000]
Activity['magnitude'] = magnitude(Activity)
with open(
'/home/ahmed/Desktop/flaskTherapio/AccFtr/' + csvfile[1][17:] +
'_Features.csv', 'w') as out:
rows = csv.writer(out)
for f in features(Activity):
rows.writerow(f)
ActivityDataFeature = pd.read_csv(
'/home/ahmed/Desktop/flaskTherapio/AccFtr/' + csvfile[1][17:] +
'_Features.csv',
header=None)
# return ActivityDataFeature.reset_index().to_json(orient='index')
# CSVDATA = json.dumps(csv_files_dict)
########################################
########################################
# Phone calls processing and features extraction
#########################################
#########################################
#########################################
curWAV, conn = connection()
reqWAV = "SELECT * FROM files AS f WHERE f.uid = %s and f.type = 'WAV' "
curWAV.execute(reqWAV, userid)
WAVfiles = curWAV.fetchall()
wavs_dict = []
for wavf in WAVfiles:
wavf_dict = {
'Id': wavf[0],
'filepath': wavf[1],
'type': wavf[2],
'createdat': wavf[3],
'uid': wavf[4]
}
wavs_dict.append(wavf_dict)
#print wavs_dict.__len__()
print len(WAVfiles)
ind = 0
patho = "/home/ahmed/Desktop/flaskTherapio/"
for wavfile in WAVfiles:
ind += 1
print "checking database for the " + str(ind) + " time"
dirPath = wavfile[1][1:17]
wavName = wavfile[1][17:]
wavdate = wavfile[3][1:10]
#print dirPath
print wavName
print wavdate
ftp.cwd("/" + dirPath)
print "done changing directory"
audiofilematch = '*.wav'
cc = 0
error = False
for filename in ftp.nlst(
audiofilematch): # Loop - looking for WAV files
if error == False:
cc += 1
print "checking FTP for the " + str(cc) + " time"
print "comparing " + wavName + " and " + filename
print wavName == filename
fhandle = open(filename, 'wb')
print 'Getting ' + filename
os.chdir("/home/ahmed/Desktop/flaskTherapio/")
ftp.retrbinary('RETR ' + filename, fhandle.write)
print "stored"
fhandle.close()
if filename == wavName:
print " just do this shit here"
sound = AudioSegment.from_file(patho + filename)
sound.export(patho + "PhoneCallsFtr/" + filename + ".wav",
format="wav")
loudness = sound.rms
#number of Frames
nf = sound.frame_count()
# Value of loudness
loudness = sound.rms
#duration
dur = sound.duration_seconds
#max
madmax = sound.max
#max possible amplitude
MPA = sound.max_possible_amplitude
#max dbfs
maxDBFS = sound.max_dBFS
samplewidth = sound.sample_width
today = datetime.datetime.today().strftime("%m/%d/%Y")
blahblah = patho + "PhoneCallsFtr/" + filename + ".wav"
print "Blah blah path : ======> " + blahblah
[Fs, x] = audioBasicIO.readAudioFile(blahblah)
#silence removal ---- into segments
segments = aS.silenceRemoval(x,
Fs,
0.030,
0.030,
smoothWindow=0.3,
Weight=0.6,
plot=True)
numbPauses = len(segments) - 1
if numbPauses:
error = False
else:
error = True
print "num pauses : " + str(numbPauses)
# SELECT * FROM `phoneCallFeatures` WHERE (`created_at` BETWEEN 60 AND 1500) AND (uid = '5795028d168257.04609170')
# SQL query to insert phone call features to DB
insertFtrReq = """INSERT INTO phoneCallFeatures
(uid,
npause,
loudness,
maxA,
created_at)
VALUES (%s,
%s,
%s,
%s,
%s)""", (userid,
numbPauses,
loudness,
madmax, wavdate)
curInsertFtr, conn = connection()
curInsertFtr.execute(*insertFtrReq)
conn.commit()
# short term features extraction
fw = audioFeatureExtraction.stFeatureExtraction(
x, Fs, 0.1 * Fs, 0.1 * Fs)
print fw
# Mid term feature extraction
#F1 = audioFeatureExtraction.mtFeatureExtraction(x, Fs, 0.050*Fs, 0.050*Fs,0.050*Fs, 0.050*Fs)
mypath = "/home/ahmed/Desktop/flaskTherapio/PhoneCallsFtr/"
if not os.path.isdir(mypath):
os.makedirs(mypath)
numpy.savetxt(mypath + wavName + "_AllStFtrs.csv",
fw,
delimiter=",")
#numpy.savetxt("00_AllMidFtrs.csv", F1, delimiter=",")
# read features in a data frame
phoneCallFtrPrime = pd.read_csv(mypath + wavName +
"_AllStFtrs.csv")
COLUMNS = []
for i in range(0, len(phoneCallFtrPrime.columns)):
COLUMNS.append('Frame' + str(i + 1))
COLUMNS.append('label')
phoneCallFtrFinal = pd.read_csv(mypath + wavName +
"_AllStFtrs.csv",
header=None,
names=COLUMNS)
numOfFtrs = len(phoneCallFtrFinal["label"])
phoneCallFtrFinal.label = phoneCallFtrFinal.label.astype(
float).fillna(0)
# phoneCallFtrFinal.label = phoneCallFtrFinal.label.astype(int).fillna(0)
for j in range(0, numOfFtrs):
phoneCallFtrFinal.iloc[j]['label'] = 0
#jsonFeatures = phoneCallFtrFinal.reset_index().to_json(orient='index')
#jsonFeatures = phoneCallFtrFinal.to_json(orient=None)
display(phoneCallFtrFinal.head())
#print "JSON Features of every audio ----------------------------------------------"
#print jsonFeatures
else:
print " Moving to the next file"
curPhone, conn = connection()
reqPhoneCallFtr = """SELECT * FROM phoneCallFeatures WHERE
created_at BETWEEN %s AND %s
AND uid = %s""", (starttime, today, userid)
curPhone.execute(*reqPhoneCallFtr)
calls = curPhone.fetchall()
calls_dict = []
for call in calls:
call_dict = {
'Id': call[0],
'IdUniq': call[1],
'npause': call[2],
'loudness': call[3],
'maxA': call[4],
'createdat': call[5],
}
calls_dict.append(call_dict)
#callJsonData = json.dumps(calls_dict)
#LoadJsonData = json.loads(callJsonData)
#print "JSON calls data ----------------------------------------------"
#print LoadJsonData
#print LoadJsonData['loudness']
return render_template('dashboard.html',
userid=userid,
loudness=loudness,
nf=nf,
dur=dur,
maxDBFS=maxDBFS,
madmax=madmax,
MPA=MPA,
jsonFeatures=jsonFeatures,
starttime=starttime,
form=form)
def silence_remove(x, option, pic, limit, **params):
'''
:param x: 输入信号
:param limit: 门限
:param option: 选择使用希尔伯特方法还是低通滤波方法
:param pic: bool选择是否画图并保存
:param params: 用于低通滤波器的参数
:return:
'''
if option is 'hilbert':
analytic_signal = signal.hilbert(x)
z = np.abs(analytic_signal)
if pic:
plt.figure()
ax1 = plt.subplot(311)
ax1.plot(x, 'r')
ax1.set_title('original signal')
ax1.set_xlabel('Time')
ax1.set_ylabel('value')
ax2 = plt.subplot(312)
ax2.plot(z, 'b')
ax2.set_title('envelope')
ax2.set_xlabel('Time')
ax2.set_ylabel('value')
ax3 = plt.subplot(313)
ax3.plot(x[z > limit], 'g')
ax3.set_title('silence_remove_hilbert')
ax3.set_xlabel('Time')
ax3.set_ylabel('value')
plt.tight_layout()
plt.savefig(str(pic) + '.jpg')
plt.clf()
plt.close()
return x[z > limit]
elif option is 'HF':
z = hilbert_filter(x=x, **params)
if pic:
plt.figure()
ax1 = plt.subplot(311)
ax1.plot(x, 'r')
ax1.set_title('original signal')
ax1.set_xlabel('Time')
ax1.set_ylabel('value')
ax2 = plt.subplot(312)
ax2.plot(z, 'b')
ax2.set_title('envelope')
ax2.set_xlabel('Time')
ax2.set_ylabel('value')
ax3 = plt.subplot(313)
ax3.plot(x[z > limit], 'g')
ax3.set_title('silence_remove_hilbert_filter')
ax3.set_xlabel('Time')
ax3.set_ylabel('value')
plt.tight_layout()
plt.savefig(str(pic) + '.jpg')
plt.clf()
plt.close()
return x[z > limit]
elif option is 'SVM':
domain = seg.silenceRemoval(x, **params)
y = x[::]
a = 0
c = len(x)
for i in domain[::-1]:
a = i[0] * params['fs']
b = i[1] * params['fs']
y = np.delete(y, np.arange(b, c, 1))
c = a
y = np.delete(y, np.arange(0, a, 1))
if pic:
plt.figure()
ax1 = plt.subplot(211)
ax1.plot(x, 'r')
ax1.set_title('original signal')
ax1.set_xlabel('Time')
ax1.set_ylabel('value')
ax2 = plt.subplot(212)
ax2.plot(y, 'b')
ax2.set_title('silence_remove_SVM')
ax2.set_xlabel('Time')
ax2.set_ylabel('value')
plt.tight_layout()
plt.savefig(str(pic) + '.jpg')
# plt.show()
plt.clf()
plt.close()
return y
else:
z = lp_filter(x, **params)
if pic:
plt.figure()
ax1 = plt.subplot(311)
ax1.plot(x, 'r')
ax1.set_title('original signal')
ax1.set_xlabel('Time')
ax1.set_ylabel('value')
ax2 = plt.subplot(312)
ax2.plot(z, 'b')
ax2.set_title('output of filter')
ax2.set_xlabel('Time')
ax2.set_ylabel('value')
ax3 = plt.subplot(313)
ax3.plot(x[z > limit], 'g')
ax3.set_title('silence_remove_filter')
ax3.set_xlabel('Time')
ax3.set_ylabel('value')
plt.tight_layout()
# plt.savefig(str(pic) + '.jpg')
plt.show()
# plt.clf()
# plt.close()
return x[np.abs(z) > limit]
class noiseCleaner:
def __init__(self, smoothingWindow=0.4, weight=0.4, sensitivity=0.4, debug=False,
verbose=False, num_threads=0):
self.smoothingWindow = smoothingWindow
self.weight = weight
self.sensitivity = sensitivity
self.debug = debug
self.verbose = verbose
self.num_threads = num_threads
#This function performs noise removal for a single file
#in some cases the process will fail, either because the file is too short or because activity is constant and therfore a noise profile cannot be generated
#in this case the function will simply make a copy of the original file into the "clean" folder to feed to the classifier
def noise_removal(self, inputFile):
smoothingWindow = self.smoothingWindow
weight = self.weight
sensitivity = self.sensitivity
debug = self.debug
verbose = self.verbose
if verbose:
print inputFile
if not os.path.isfile(inputFile):
raise Exception(inputFile + " not found!")
[Fs, x] = audioBasicIO.readAudioFile(inputFile) # read audio signal
dir, inputFile = os.path.split(inputFile)
try:
create_subdirectory(dir, 'noise')
create_subdirectory(dir, 'activity')
root, current_sub_dir = os.path.split(dir)
clean_dir = '_'.join([current_sub_dir, 'clean'])
create_subdirectory(dir, clean_dir)
except OSError, e:
if e.errno != 17:
raise
# time.sleep might help here
pass
try:
segmentLimits = aS.silenceRemoval(x, Fs, smoothingWindow / 10.0, smoothingWindow / 10.0, smoothingWindow,
weight, False) # get onsets
prev_end = 0
activity_files = []
noise_files = []
for i, s in enumerate(segmentLimits):
strOut = os.path.join(dir, "noise", "{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], prev_end, s[0]))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):int(Fs * s[0])])
noise_files.append(strOut)
strOut = os.path.join(dir, "activity", "{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], s[0], s[1]))
wavfile.write(strOut, Fs, x[int(Fs * s[0]):int(Fs * s[1])])
activity_files.append(strOut)
prev_end = s[1]
strOut = os.path.join(dir, "noise",
"{0:s}_{1:.3f}-{2:.3f}.wav".format(inputFile[0:-4], prev_end, len(x) / Fs))
wavfile.write(strOut, Fs, x[int(Fs * prev_end):len(x) / Fs])
noise_files.append(strOut)
activity_out = os.path.join(dir, "activity", inputFile)
noise_out = os.path.join(dir, "noise", inputFile)
recombine_wavfiles(noise_files, noise_out)
recombine_wavfiles(activity_files, activity_out)
tfs = sox.Transformer()
noise_profile_path = '.'.join([noise_out, 'prof'])
tfs.noiseprof(noise_out, noise_profile_path)
tfs.build(noise_out, '-n')
tfs.clear_effects()
tfs.noisered(noise_profile_path, amount=sensitivity)
clean_out = os.path.join(dir, clean_dir, inputFile)
tfs.build(activity_out, clean_out)
except:
original_file = os.path.join(dir, inputFile)
sys.stderr.write("Sox error in noise reduction of file: %s.\n" % original_file)
clean_out = os.path.join(dir, clean_dir, inputFile)
shutil.copyfile(original_file, clean_out)
with open(os.path.join(dir, clean_dir, 'NR_fail_record.log'), 'a') as fail_record:
fail_record.write('%s\n' % original_file)
if not debug:
shutil.rmtree(os.path.join(dir, "noise"))
shutil.rmtree(os.path.join(dir, "activity"))
return clean_out
