def make_feature_server(dirname, frame_size):
"""Return a Sidekit FeatureServer instance for this
experiement
"""
sampling_frequency = 16000
# window size must be twice the frame size to give the right number of FFT points but since
# we can't zero pad, we'll be taking in more of the signal in each frame
window_size = (2* frame_size+1) / sampling_frequency
shift = 0.008
# make a feature server to compute features over our audio files
extractor = sidekit.FeaturesExtractor(audio_filename_structure=dirname + "/{}.wav",
sampling_frequency=sampling_frequency,
lower_frequency=0,
higher_frequency=sampling_frequency/2,
filter_bank="lin",
filter_bank_size=frame_size,
window_size=window_size,
shift=shift,
ceps_number=20,
pre_emphasis=0.97,
save_param=["fb"],
keep_all_features=False)
server = sidekit.FeaturesServer(features_extractor=extractor,
sources=None,
dataset_list=["fb"],
keep_all_features=True)
return server
def calculateOneEmbedding(model, eval_feature_path, path):
server = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure=eval_feature_path + "/{}.h5",
sources=None,
dataset_list=["energy", "cep", "vad"],
mask="[0-19]",
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=True,
double_delta=False,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
feature, _ = server.load(path, channel=0)
feature = feature.astype(np.float32)
feature = torch.tensor(feature).unsqueeze(0)
feature = feature.unsqueeze_(0)
embedding, _ = model(feature)
embedding = embedding / embedding.pow(2).sum(dim=1).sqrt()
return embedding # calculate the embedding
def train_ubm(self,
feature_dir,
speaker_list,
ubm_list,
distrib_nb,
feature_extension='h5',
num_threads=10):
'''
training the GMM with EM-Algorithm
'''
self.logger.info('training UBM')
fs = sidekit.FeaturesServer(feature_filename_structure=(
"{dir}/{speaker_list}/feat/{{}}.{ext}".format(
dir=feature_dir,
speaker_list=speaker_list,
ext=feature_extension)),
dataset_list=["energy", "cep", "vad"],
mask="[0-12]",
feat_norm="cmvn",
keep_all_features=True,
delta=True,
double_delta=True,
rasta=True,
context=None)
ubm = sidekit.Mixture()
llk = ubm.EM_split(fs, ubm_list, distrib_nb, num_thread=num_threads)
ubm.write(get_experiment_nets() +
'/ubm_{}.h5'.format(self.network_file))
return ubm, fs
def __getitem__(self, index):
features_server = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure='../all_feature/{}.h5',
sources=None,
dataset_list=['fb'],
mask=None,
feat_norm='cms',
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=False,
double_delta=False,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
show_list = self.speech[index]
speaker = show_list.split('/')[0]
features, _ = features_server.load(show_list, channel=0)
features = features.astype(np.float32)
ind = np.argwhere(self.speakers_dir == speaker)[0]
label = ind.astype(
np.int64)[0] #这里只要指出label所在的索引就好了，比如是第20个说话人说的，那么label就是[20]
features = features.reshape(1, features.shape[1], features.shape[0])
features = t.tensor(features)
img = transforms.ToPILImage()(features)
features = transforms.Resize((24, 400))(img)
features = transforms.ToTensor()(features)
return features.view(features.size()[1], features.size()[2]), label
def remove(path):
'''
remove the h5 file which cannot be read
param:
path : trainset feature path
'''
server = sidekit.FeaturesServer(features_extractor=None,
feature_filename_structure=path + "/{}.h5",
sources=None,
dataset_list=["fb", "vad"],
mask=None,
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=False,
double_delta=False,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
speaker = os.listdir(path)
for s in speaker:
speaker_path = os.path.join(path, s)
speech = os.listdir(speaker_path)
for sph in speech:
speech_path = s + '/' + sph.split('.')[0]
try:
feature, _ = server.load(speech_path, 0)
except:
os.remove(os.path.join(speaker_path, sph))
print('done')
def adaptation(args):
if args.feat_type == 'mfcc':
datasetlist = ["energy", "cep", "vad"]
mask = "[0-12]"
features_folder = '/home/zeng/zeng/aishell/af2019-sr-devset-20190312/feature'
if args.feat_type == 'fb':
datasetlist = ["fb", "vad"]
mask = None
features_folder = '/home/zeng/zeng/aishell/af2019-sr-devset-20190312/feature'
# create feature server for loading feature from disk
feature_server = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure=features_folder + "/{}.h5",
sources=None,
dataset_list=datasetlist,
mask=mask,
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=True if args.delta else False,
double_delta=True if args.delta else False,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
enroll_idmap = sidekit.IdMap(os.getcwd() + '/task/idmap.h5')
ndx = sidekit.Ndx(os.getcwd() + '/task/dev_ndx.h5')
ubm = sidekit.Mixture()
ubm.read(os.getcwd() + '/model/ubm.h5')
enroll_stat = sidekit.StatServer(enroll_idmap,
distrib_nb=ubm.distrib_nb(),
feature_size=ubm.dim())
enroll_stat.accumulate_stat(ubm=ubm,
feature_server=feature_server,
seg_indices=range(enroll_stat.segset.shape[0]),
num_thread=args.num_thread)
enroll_stat.write(os.getcwd() + '/task/enroll_stat.h5')
print('MAP adaptation', end='')
regulation_factor = 16
enroll_sv = enroll_stat.adapt_mean_map_multisession(ubm, regulation_factor)
enroll_sv.write(os.getcwd() + '/task/enroll_sv.h5')
print('\rMAP adaptation done')
print('Compute scores', end='')
score = sidekit.gmm_scoring(ubm,
enroll_sv,
ndx,
feature_server,
num_thread=args.num_thread)
score.write(os.getcwd() + '/task/dev_score.h5')
print('\rCompute scores done')
def train_ubm(**args):
if args['feat_type'] == 'mfcc':
datasetlist = ["energy", "cep", "vad"]
mask = "[0-12]"
features_folder = '/home/zeng/zeng/aishell/aishell2/ios/data/feature'
if args['feat_type'] == 'fb':
datasetlist = ["fb", "vad"]
mask = None
features_folder = '/home/zeng/zeng/aishell/aishell2/ios/data/feature'
utils.remove(features_folder)
ubmlist = []
if os.path.exists(os.getcwd() + '/log/aishell2_wavlist.log'):
with open(os.getcwd() + '/log/aishell2_wavlist.log', 'r') as fobj:
for i in fobj:
ubmlist.append(i[0:-1])
else:
ubmlist = preprocess()
# create feature server for loading feature from disk
server = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure=features_folder + "/{}.h5",
sources=None,
dataset_list=datasetlist,
mask=mask,
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=args['delta'],
double_delta=args['delta'],
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
# create Mixture object for training
ubm = sidekit.Mixture()
ubm.EM_split(server,
ubmlist,
args['distribNum'],
iterations=(1, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8),
num_thread=args['num_thread'],
save_partial=True)
# write trained ubm to disk
ubm.write(os.getcwd() + '/model/ubm_512.h5')
def get_feature_server(self, feature_filename_structure, delta=True, double_delta=True,
dataset_list=["energy", "cep", "vad"], feat_norm="cmvn",
keep_all_features=False):
server = sidekit.FeaturesServer(feature_filename_structure=feature_filename_structure,
dataset_list=dataset_list,
mask=None,
feat_norm=feat_norm,
delta=delta,
double_delta=double_delta,
rasta=True,
context=None,
keep_all_features=keep_all_features)
return server
def make_feature_server():
"""Return a Sidekit FeatureServer instance for this
experiement
config: DATA_DIR, FEAT_DIR
"""
dd = config('DATA_DIR')
fd = config('FEAT_DIR')
# TODO: more of these settings should be derived from the config file
# make a feature server to compute features over our audio files
extractor = sidekit.FeaturesExtractor(audio_filename_structure=dd+'{}.wav',
feature_filename_structure=fd+"{}.h5",
sampling_frequency=None,
lower_frequency=200,
higher_frequency=3800,
filter_bank="log",
filter_bank_size=24,
window_size=0.025,
shift=0.01,
ceps_number=20,
vad="snr",
snr=40,
pre_emphasis=0.97,
save_param=["vad", "energy", "cep", "fb"],
keep_all_features=True)
server = sidekit.FeaturesServer(features_extractor=extractor,
feature_filename_structure=fd+"{}.h5",
sources=None,
dataset_list=["energy", "cep", "vad"],
mask="[0-12]",
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=True,
double_delta=True,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=True)
return server
def train_ubm(**args):
if (args['feat_type'] == 'mfcc') or (args['feat_type'] == 'plp'):
datasetlist = ["energy", "cep", "vad"]
mask = "[0-19]"
if args['feat_type'] == 'fb':
datasetlist = ["fb", "vad"]
mask = None
features_folder = os.getcwd() + '/{}_train_feature'.format(
args['feat_type'])
ubmlist = []
try:
with open(os.getcwd() + '/log/aishell2.log', 'r') as fobj:
for i in fobj:
ubmlist.append(i[0:-1])
except FileNotFoundError:
print('please generate ubm wav list as first')
# create feature server for loading feature from disk
server = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure=features_folder + "/{}.h5",
sources=None,
dataset_list=datasetlist,
mask=mask,
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=args['delta'],
double_delta=args['delta'],
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
# create Mixture object for training
ubm = sidekit.Mixture()
ubm.EM_split(server,
ubmlist,
args['distribNum'],
iterations=(1, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8),
num_thread=args['num_thread'],
save_partial=True)
# write trained ubm to disk
ubm.write(os.getcwd() + '/model/ubm_512.h5')
def __init__(self, path, maxlen):
super(DeepSpkDataset, self).__init__()
pattern = re.compile(r'^S\d{4}')
server = sidekit.FeaturesServer(features_extractor=None,
feature_filename_structure=path+"/{}.h5",
sources=None,
dataset_list=["energy","cep","vad"],
mask="[0-19]",
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=True,
double_delta=False,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
self.server = server
self.maxlen = maxlen
speakers_list = os.listdir(path)
speakers_dir = []
for i in range(len(speakers_list)):
if re.match(pattern, speakers_list[i]):
speakers_dir.append(path + '/' + speakers_list[i])
speech = []
num_speakers = 0
real_speakers_list = []
for i in speakers_dir:
speech_list = os.listdir(i)
if len(speech_list) > 20:
for j in speech_list:
show = i.split('/')[-1] + '/' + j.split('.')[0]
speech.append(show)
num_speakers += 1
real_speakers_list.append(i.split('/')[-1])
self.speech = np.asarray(speech)
self.num_speakers = num_speakers
self.speakers_list = np.asarray(real_speakers_list)
a = [np.argwhere(self.speakers_list == i.split('/')[0])[0] for i in self.speech] # 对每个语音生成label
self.train_labels = torch.tensor(a, dtype = torch.int64)
self.train_labels.squeeze_()
def __init__(self):
self.extra = None
super(Fea, self).__init__(
audio_filename_structure=None,
feature_filename_structure=
None, # the 2nd is channel ,it is added by me
sampling_frequency=8000,
lower_frequency=200,
higher_frequency=3800,
filter_bank="log",
filter_bank_size=40,
window_size=0.025,
shift=0.01,
ceps_number=12,
vad="energy",
pre_emphasis=0.97,
save_param=["vad", "energy", "cep", "fb"],
keep_all_features=True)
self.feaServer = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure=None,
sources=None,
dataset_list=None, # ["energy","cep","fb"],
feat_norm=None,
# cms cmvn stg cmvn_sliding cms_sliding,there do not do it ,we can do it in next step
delta=True,
double_delta=True,
rasta=True,
keep_all_features=False,
# mask="[0-12]",
# global_cmvn=None,
# dct_pca=False,
# dct_pca_config=None,
# sdc=False,
# sdc_config=None,
# delta_filter=None,
# context=None,
# traps_dct_nb=None,
)
def createFeatureServer(self, group=None):
if group:
feat_dir = os.path.join(self.BASE_DIR, "feat", group)
else:
feat_dir = os.path.join(self.BASE_DIR, "feat")
# feature_filename_structure: structure of the filename to use to load HDF5 files
# dataset_list: string of the form ["cep", "fb", vad", energy", "bnf"]
# feat_norm: type of normalization to apply as post-processing
# delta: if True, append the first order derivative
# double_delta: if True, append the second order derivative
# rasta: if True, perform RASTA filtering
# keep_all_features: boolean, if True, keep all features, if False, keep frames according to the vad labels
server = sidekit.FeaturesServer(
feature_filename_structure=os.path.join(feat_dir, "{}.h5"),
dataset_list=["vad", "energy", "cep", "fb"],
feat_norm="cmvn",
delta=True,
double_delta=True,
rasta=True,
keep_all_features=True)
logging.info("Feature-Server is created")
logging.debug(server)
return server
def featureServer(ext):
fs = sidekit.FeaturesServer(
features_extractor=ext,
feature_filename_structure=None,
sources=None, #['cep'],
dataset_list=['cep', 'fb', 'vad', 'energy'],
#dataset_list=["cep"],
mask="[0-12]",
#mask = None,
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=True,
double_delta=True,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
return fs
def get_embeddings(self):
'''
finally, testing:
'''
speaker_list = self.get_validation_data_name()
distrib_nb = self.config.getint('i_vector', 'distrib_nb')
nbThread = self.config.getint('i_vector', 'nbThread')
vector_size = self.config.getint('i_vector', 'vector_size')
feature_extension = 'h5'
set_of_embeddings = []
set_of_speakers = []
set_of_num_embeddings = []
set_of_times = []
checkpoints = ["/TV_{}".format(self.network_file)]
#load data:
ubm = sidekit.Mixture()
ubm.read(get_experiment_nets() +
'/ubm_{}.h5'.format(self.network_file))
ubm_list, test_list_long = self.load_data(
speaker_list,
os.path.splitext(
os.path.split(self.get_validation_train_data())[1])[0])
ubm_list, test_list_short = self.load_data(
speaker_list,
os.path.splitext(
os.path.split(self.get_validation_test_data())[1])[0])
tv, tv_mean, tv_sigma = sidekit.sidekit_io.read_tv_hdf5(
get_experiment_nets() + "/TV_{}".format(self.network_file))
fs = sidekit.FeaturesServer(feature_filename_structure=(
"{dir}/{speaker_list}/feat/{{}}.{ext}".format(
dir=get_training('i_vector'),
speaker_list=speaker_list,
ext=feature_extension)),
dataset_list=["energy", "cep", "vad"],
mask="[0-12]",
feat_norm="cmvn",
keep_all_features=True,
delta=True,
double_delta=True,
rasta=True,
context=None)
#exract ivectors
test_stat_long = sidekit.StatServer(test_list_long,
ubm=ubm,
distrib_nb=distrib_nb,
feature_size=0,
index=None)
test_stat_long.accumulate_stat(ubm=ubm,
feature_server=fs,
seg_indices=range(
test_stat_long.segset.shape[0]),
num_thread=nbThread)
test_stat_short = sidekit.StatServer(test_list_short,
ubm=ubm,
distrib_nb=distrib_nb,
feature_size=0,
index=None)
test_stat_short.accumulate_stat(ubm=ubm,
feature_server=fs,
seg_indices=range(
test_stat_short.segset.shape[0]),
num_thread=nbThread)
test_iv_long = test_stat_long.estimate_hidden(tv_mean,
tv_sigma,
V=tv,
batch_size=100,
num_thread=nbThread)[0]
test_iv_short = test_stat_short.estimate_hidden(tv_mean,
tv_sigma,
V=tv,
batch_size=100,
num_thread=nbThread)[0]
iv_lis, y_list, s_list = create_data_lists(
False, test_iv_long.stat1, test_iv_short.stat1,
test_list_long.leftids.astype(int),
test_list_short.leftids.astype(int))
#generate embeddings
embeddings, speakers, num_embeddings = generate_embeddings(
iv_lis, y_list, vector_size)
set_of_embeddings.append(embeddings)
set_of_speakers.append(speakers)
set_of_num_embeddings.append(num_embeddings)
set_of_times = [
np.zeros(
(len(test_list_long.leftids) + len(test_list_short.leftids), ),
dtype=int)
]
return checkpoints, set_of_embeddings, set_of_speakers, set_of_num_embeddings, set_of_times
for nk in keep_sessions.nistkey:
keep_sessions.filename[keep_sessions.nistkey == nk] = file_dict[nk]
audio_file_list = keep_sessions.filename.as_matrix()
unique_idx = np.unique(audio_file_list, return_index=True)
audio_file_list = audio_file_list[unique_idx[1]]
feature_file_list = keep_sessions.nistkey.as_matrix()[unique_idx[1]]
with open('sph_files_to_process.p', "wb" ) as f:
pickle.dump( (audio_file_list, feature_file_list), f)
print("Found {} sphere files to process\n".format(feature_file_list.shape[0]))
fs = sidekit.FeaturesServer(input_dir='',
input_file_extension='.sph',
label_dir='./',
label_file_extension='.lbl',
from_file='audio',
config='sid_8k')
idx = np.arange(len(audio_file_list))
random.shuffle(idx)
audio_file_list = audio_file_list[idx]
feature_file_list = feature_file_list[idx]
fs.save_parallel(audio_file_list, feature_file_list, 'spro4', feature_root_dir,
'.mfcc', and_label=False, numThread=nbThread)
keysX.append(
sidekit.Key('task/sre10_coreX-coreX_det{}_key.h5'.format(cond + 1)))
with open('task/ubm_list.txt', 'r') as inputFile:
ubmList = inputFile.read().split('\n')
if train:
# %%
#################################################################
# Process the audio to generate MFCC
#################################################################
print('Create the feature server to extract MFCC features')
fs = sidekit.FeaturesServer(input_dir=audioDir,
input_file_extension='.mfcc',
label_dir='./',
label_file_extension='.lbl',
from_file='spro4',
config='sid_8k',
keep_all_features=False)
# %%
#################################################################
# Train the Universal background Model (UBM)
#################################################################
print('Train the UBM by EM')
ubm = sidekit.Mixture()
llk = ubm.EM_split(fs, ubmList, distribNb, numThread=nbThread)
ubm.save_pickle('gmm/ubm_bnf.p')
# %%
#################################################################
def process(self, data_loaders, outputs):
# Groups available:
# Group 0:
# Input "model" with type "system/text/1"
# Input "file_id" with type "system/text/1"
# Input "speech" with type "system/array_1d_floats/1"
# Input "speakers" with type "allies/speakers/1"
# Input "uem" with type "allies/uemranges/1"
# Output "model" with type "system/text/1"
# Output "file_id" with type "system/array_1d_text/1"
# Output "speakers" with type "allies/speakers/1"
# Create a Loader object to access all "inputs" from the previous blocks
# Although this loader seems to focus on "features" is allows to access all "inputs"
loader = data_loaders.loaderOf("features")
# Get the model
model_loader = data_loaders.loaderOf("model")
model = pickle.loads(bytes(model_loader[0][0]['model'].text , "latin-1"))
#import ipdb
#ipdb.set_trace()
# Fill a dictionnary to access features from the files
name_dict = {}
for i in range(loader.count()):
file_id = loader[i][0]['file_info'].file_id
name_dict[file_id] = int(i)
# Create a sidekit.FeaturesServer object to load features from the platform
fe = AlliesExtractor(loader,name_dict)
fs = sidekit.FeaturesServer(features_extractor=fe,
dataset_list = ['cep'],
keep_all_features=True,
delta=False,
double_delta=False)
# Here is the loop on files to process
# get the features
# get the UEM
# get the file_info
for i in range(loader.count()):
end = i
(data, _, end) = loader[i]
#uem = uem_loader[i][0]
file_id = data['file_info'].file_id
supervision = data['file_info'].supervision
time_stamp = data['file_info'].time_stamp
"""
Main diarization adaptation
"""
# Compute the result to return (without system adaptation)
spk = []
st = []
en = []
for seg in model['global_diar']:
#import ipdb
#ipdb.set_trace()
spk.append(seg[1])
st.append(numpy.cast['float64'](seg[3])/100.)
en.append(numpy.cast['float64'](seg[4])/100.)
outputs['speakers'].write({ 'speaker': spk, 'start_time': st, 'end_time': en }, i)
"""
cep = inputs['features'].data
show = inputs['file_id'].data.text
local_diar = first_pass_segmentation(cep, show)
# Extract i-vectors within-show and perform within-show clustering
iv_diar = iv_clustering(local_diar, self.model, self.fs)
# Modify the cluster ID to add the show id as a prefix
for seg in iv_diar.segments:
seg['show'] = show + '_' + seg['show']
self.global_diar.segments += iv_diar.segments
# Perform cross show iv-clustering
cross_diar = iv_clustering(global_diar, self.model, self.fs)
# Si on adapte le modèle PLDA
self.model = adapt_plda(input_diar, model, features_server)
outputs.write({'model' : self.model}) # maqnque une serialisation
outputs.write({'diarization' : cross_diar}) # A modifier pour utiliser les formats créés par Olivier
# always return True, it signals BEAT to continue processing
"""
model = pickle.dumps(model).decode('latin-1')
outputs['model'].write({'text': model}, end)
# always return True, it signals BEAT to continue processing
return True
net = Net()
data = np.load("mean_std.npz")
input_mean = data["mean"]
input_std = data["std"]
# split the list of files to process
training_segment_sets = [seg_list[i:i + segment_buffer_size]
for i in range(0, len(seg_list), segment_buffer_size)]
# Initialized cross validation error
last_cv_error = -1 * numpy.inf
for ep in range(nb_epoch):
print("Start epoch {} / {}".format(ep + 1, nb_epoch))
features_server = sidekit.FeaturesServer(**fs_params)
running_loss = accuracy = n = nbatch = 0.0
# Move model to requested device (GPU)
net.to(device)
# Set training parameters
criterion = torch.nn.CrossEntropyLoss(reduction='sum')
optimizer = torch.optim.Adam(net.parameters())
for idx_mb, file_list in enumerate(training_segment_sets):
l = []
f = []
for idx, val in enumerate(file_list):
show, s, _, label = val
#show = show.replace("/",os.path.sep)
extractor.save_list(show_list=show_list,
channel_list=channel_list,
num_thread=nbThread)
# Create a FeaturesServer
features_server = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure="./features/{}.h5",
sources=None,
dataset_list=["energy", "cep", "vad"],
mask=None,
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=True,
double_delta=True,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=True,
keep_all_features=False)
# Train the Universal background Model (UBM)
print('Train the UBM by EM')
# Extract all features and train a GMM without writing to disk
ubm = sidekit.Mixture()
ceps_number=13,
# vad="snr",
# snr=10,
pre_emphasis=0.97,
save_param=["energy", "cep", "fb"],
keep_all_features=True)
server = sidekit.FeaturesServer(features_extractor=extractor,
feature_filename_structure="chunks_features/all_train/{}.h5",
# sources=None,
dataset_list=["energy", "cep", "fb"],
mask="[0-12]",
feat_norm="cmvn",
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
# sdc_config=(1,3,7),
delta=True,
double_delta=True,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=False,
keep_all_features=True)
print('Train the UBM by EM')
# Extract all features and train a GMM without writing to disk
ubm = sidekit.Mixture()
llk = ubm.EM_split(server, utter_list, distribNb)#, num_thread=nbThread)
pickle.dump(ubm,open("ubm_64.pkl","wb"))
'/home/adit/Desktop/DCASE2017-baseline-system-master/Text_DCASE/fold1_train_names.txt'
) as inputFile:
ubmList = inputFile.read().split('\n')
nameList = []
for a in ubmList:
nameList.append(a.rsplit(".")[0])
features_server = sidekit.FeaturesServer(
features_extractor=None,
feature_filename_structure="../HDF5_DCASE/Features/{}.h5",
sources=None,
dataset_list=["fb"],
mask=None,
feat_norm='cms', #'cmvn'
global_cmvn=None,
dct_pca=False,
dct_pca_config=None,
sdc=False,
sdc_config=None,
delta=False,
double_delta=False,
delta_filter=None,
context=None,
traps_dct_nb=None,
rasta=False,
keep_all_features=None)
print('Train the UBM by EM')
# Extract all features and train a GMM without writing to disk
distribNb = 512 #np.power(2,i)
ubm = sidekit.Mixture()
p = "/home/adit/Desktop/"
print('__1__llk for ' + str(distribNb))
