Hello, I am a beginner in the field of artificial intelligence
For my first project I wanted to create an AI to recognize the spoken language in an audio.
I used librosa to extract mfcc from audios and sklearn to train and test with train_test_split with my two lists.
I have an accuracy around 30% after ~30 epochs but i want to increase by any way from 30 to 70% . I got around 500 audio files and i want to keep this number.
if someone can help me 
def feature_extractor ( audio_file_dir ):
# load the audio files
x , freq = librosa.load( audio_file_dir,sr= 16000)
# trim the first 5 seconds ( Sequence Truncation )
x_5sec =x[: 5*16000 ]
# extract 20 MFCCs
mfccs_5sec = librosa.feature.mfcc ( x_5sec , sr=freq , n_mfcc =20 )
# return mfcc of the first 5 sec as the audio file feature
return mfccs_5sec
# create a dictionary for labels
#lang_dic ={'EN':[0,0,0,1] ,'FR':[0,0,1,0] ,'AR':[0,1,0,0] ,'JP':[1,0,0,0]}
lang_dic ={'EN':0 ,'FR':1 ,'AR':2 ,'JP':3 ,}
# create a list of extracted feature ( MFCC ) for files
x_data =[]
# set data_dir to the directory of your data files
data_dir = "LID_data/"
# Read file info file to get the list of audio files and their labels
file_list =[]
label_list =[]
with open ( data_dir +"Info.txt", 'r') as file :
reader = csv.reader(file)
for row in reader :
# The first column contains the file name
file_list.append(row[0])
# The last column contains the lable ( language )
label_list.append(row[-1])
# create a dictionary for labels
# create a list of extracted feature ( MFCC ) for files
x_data =[]
for audio_file in file_list :
file_feature = feature_extractor(data_dir + audio_file)
# add extracted feature to dataset
x_data.append (file_feature)
# create a list of labels for files
y_data =[]
for lang_label in label_list :
# convert the label to a value in {0,1,2,3} as the class label
y_data.append(lang_dic[lang_label])
# shuffle two lists
temp_list = list ( zip( x_data , y_data ))
random.shuffle ( temp_list )
x_data , y_data = zip (* temp_list )
X_train, X_test, Y_train, Y_test = train_test_split(x_data, y_data, test_size=0.33, random_state=42)
device ="cpu"
# transform to torch tensor
tensor_x_data = torch.Tensor( X_test)
tensor_y_data = torch.Tensor( Y_test)
tensor_x_data_train = torch.Tensor( X_train)
tensor_y_data_train = torch.Tensor( Y_train)
# create your datset
dataset = TensorDataset ( tensor_x_data , tensor_y_data )
dataset_train = TensorDataset ( tensor_x_data_train , tensor_y_data_train )
# the batch size can be changed to a lrger value when you have more data
batch_size = 1
# create your dataloader
dataloader = DataLoader ( dataset , batch_size = 1 )
dataloader_train = DataLoader (dataset_train, batch_size = batch_size)
# Get cpu or gpu device for training .
print ("Using {} device".format ( device ))
# Define model
class NeuralNetwork ( nn.Module ):
def __init__ ( self ):
super ( NeuralNetwork , self ).__init__ ()
self.flatten = nn.Flatten ()
self.linear_relu_stack = nn.Sequential (
# the size of input should be the number of features ( 20 MFCC ) times
# length of sequence ( 157 )
nn.Linear ( 20*157 , 512 ) ,
nn.ReLU () ,
nn.Dropout(0.5),
nn.Linear ( 512 , 512 ) ,
nn.ReLU () ,
nn.Dropout(0.5),
nn.Linear ( 512 , 256 ) ,
nn.ReLU () ,
nn.Dropout(0.5),
nn.Linear ( 256 , 4),
)
def forward ( self , x):
x = self.flatten (x)
logits = self.linear_relu_stack (x)
return logits
model = NeuralNetwork().to( device )
# to train a model , we need a loss function and an optimizer .
loss_fn = nn.CrossEntropyLoss ()
#optimizer = torch.optim.SGD( model.parameters() , lr=1e-2)
#optimizer = torch.optim.SGD( model.parameters() , lr=0.01)
optimizer = torch.optim.Adam(model.parameters(), lr=0.00001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)
def train ( dataloader , model , loss_fn , optimizer ):
size = len ( dataloader.dataset )
model.train ()
for batch , (X , y) in enumerate ( dataloader ):
X , y = X.to( device ) , y.to( device )
# Compute prediction error
pred = model ( X)
loss = loss_fn ( pred , y.type (torch.LongTensor))
# B a c k p r o p a g a t i o n
optimizer.zero_grad ()
loss.backward ()
optimizer.step()
if batch % 100 == 0:
loss , current = loss.item() , batch * len (X)
print (f" loss : { loss :>7f} [{ current :>5d}/{ size : >5d}]")
def test ( dataloader , model , loss_fn ):
size = len ( dataloader.dataset )
num_batches = len ( dataloader )
model.eval ()
test_loss , correct = 0 , 0
with torch.no_grad ():
for X , y in dataloader :
X , y = X.to( device ) , y.to( device )
pred = model (X)
test_loss += loss_fn ( pred , y.type( torch.LongTensor )).item () #
correct += ( pred.argmax (1) == y).sum().item ()
#correct += ( pred.argmax (1) == y).type(torch.float).sum().item ()
#print((pred.argmax (1) == y.argmax(1)).sum().item ())
test_loss /= num_batches
correct /= size
print (f" Test Error : \n Accuracy : {( 100 * correct ):>0.1f}%, Avg loss : {test_loss:>8f} \n")
number_of_epochs = 30
for t in range ( number_of_epochs ):
print (f"Epoch {t+1}\n- ----- ---- ----- ----- ---- ----- --")
train ( dataloader_train , model , loss_fn , optimizer )
test ( dataloader , model , loss_fn )
print (" Done !")