How can I predict Asthma using the lungs sound recording. || Creating a deep learning model to predict asthma using the lungs sound. | by Sunny Kumar | Nov, 2023

Enable us to bounce into our coding ground and start creating our ML model.

Since our data is in .wav sort permit us to create a carry out which may create spectrogram of each audio file and reserve it in designated itemizing.

Creating spectrogram is principally signal preprocessing, segmentation and windowing after which making use of fast Fourier transform , and lastly we present the spectrogram. Sounds an extreme quantity of subtle , don’t concern there’s a python library which may help us with the entire mathematical calculation, “librosa”. Make sure to arrange this library and import it. We’re going to use matplotlib to point out the created spectrogram.

Beneath is a sample code to load an audio file and create mel spectrorgram.

y, sr = librosa.load('sample.wav')  
spec = librosa.operate.melspectrogram(y=y, sr=sr)

Lets us create a further exhaustive carry out which may study all audio file and save generated spectrogram into our native folder for future use.

def create_spectrogram(filename,title):
plt.interactive(False)
clip, sample_rate = librosa.load(filename, sr=None)
fig = plt.decide(figsize=[0.6,0.6])
ax = fig.add_subplot(111)
ax.axes.get_yaxis().set_visible(False)
ax.axes.get_xaxis().set_visible(False)
ax.set_frame_on(False)
#magic happens from proper right here
S = librosa.operate.melspectrogram(y=clip, sr=sample_rate)
librosa.present.specshow(librosa.power_to_db(S, ref=np.max))
filename  = Path('path_to _save' + title + '.jpg')
plt.savefig(filename, dpi=500, bbox_inches="tight",pad_inches=0)
# free the entire belongings
plt.shut()    
fig.clf()
plt.shut(fig)
plt.shut('all')
del fig,ax,S,filename,title,sample_rate,clip

Plenty of the magic is going on is between these strains:-

“ S = librosa.operate.melspectrogram(y=clip, sr=sample_rate)
librosa.present.specshow(librosa.power_to_db(S, ref=np.max))
filename = Path(‘path_to _save’ + title + ‘.jpg’)
plt.savefig(filename, dpi=400, bbox_inches=’tight’,pad_inches=0)”

In plain english using above strains of code we’re are loading an audio file then creating mel spectrogram and saving it into supplied path.

Acess the itemizing using glob package deal deal of python . Contained within the loop we’re accessing each audio file one after the opposite and passing each file to our carry out “create_spectrogram(merchandise,x)” . So, as quickly as we run the code, spectrogram is likely to be generated for each audio file and saved with title extracted as per the audio file title.

“ x = merchandise.break up(“/”)[4].break up(“.”)[0]
x = str(i) + x
print(x)”

Using these three strains we’re extracting the title of our file, which we’re going to use later to create labels.

Data_dir= np.array(glob("/mypath/sounds/*"))

for i,merchandise in enumerate(Data_dir):
x = merchandise.break up("/")[4].break up(".")[0]
x  = str(i) + x
print(x)
create_spectrogram(merchandise,x)

permit us to create two arrays for footage and labels and itemizing path the place all the pictures are saved.

footage =[]
labels =[]
dir= np.array(glob("/path_spectrogram/*"))

using openCV we’re going to study and resize the image and using break up() of python we’re going to extract the label of image primarily based totally on its title.

Enable us to create a loop which entry each facet throughout the outlined itemizing .

dir= np.array(glob("/path_spectrogram/*"))
for merchandise in dir:
imagePath = merchandise
#print("learning:-",merchandise)
label = merchandise.break up('/')[0].break up("_")[1]
print("appending:-",label)
im = cv2.imread(imagePath)
im_resized = cv2.resize(im, (224, 224), interpolation=cv2.INTER_LINEAR)
footage.append(im_resized)
labels.append(label)

proper right here we’re appending all the pictures in “footage[]” array and the corresponding labels in “labels[]” array.

so proper right here labels accommodates the properly being state of affairs extracted from the audio file title.

the extracted label could also be very messy correct now. permit us to transform our labels into two lessons “Bronchial bronchial asthma”, “Not Bronchial bronchial asthma”.

y =[]
for i, merchandise in enumerate(labels):
merchandise = merchandise.lower()
if 'bronchial bronchial asthma' in merchandise:
y.append("bronchial bronchial asthma")
else:
y.append("not bronchial bronchial asthma")

Whole, we’ve got now full of 237 not bronchial bronchial asthma data and 99 data for bronchial bronchial asthma label.

permit us to reshape our array for acceptable to our CNN layer.

#altering footage to array and normalizing it
X = np.array(footage).reshape(-1, 224, 224, 3)
X = X/255

It is vitally vital label encode as our neural don’t anticipate any string , it’s simply acceptable with numeric variables. we’ve got now two selections proper right here,

1. one scorching encoding

2. simple integer

We is likely to be using “LabelEncoder()” from sklearn library, to create one scorching encoding.

what’s one scorching encoding?

One-hot encoding is a technique utilized in machine learning and pure language processing to indicate categorical variables as binary vectors.

For example, let’s say you’ll have three lessons: “apple,” “orange,” and “Banana.” You might signify them with one-hot encoding as follows:

apple : [1,0,0]

banana:[0,1,0]

orange:[0,0,1]

Each class is represented as a binary vector of measurement three, the place only one facet is 1, indicating the category.

code underneath creates the one scorching encoding for two lessons, bronchial bronchial asthma and by no means bronchial bronchial asthma.

le = LabelEncoder()
encoded_label = le.fit_transform(y) # 0 ,1 not- bronchial bronchial asthma , 1,0 bronchial bronchial asthma
y = to_categorical(encoded_label)

To know our encoding , 0,1 -> Not Bronchial bronchial asthma , 1,0-> Bronchial bronchial asthma

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 4)

Using sequential we is likely to be making a CNN model . A ingredient construction of CNN is likely to be talked about in later parts of this textual content. On this mannequin of article we is likely to be considering consequence oriented code. I’ve tried a lot of combination of layers and underneath code works higher of all.

maxpooling and dropout has aided positively in teaching time and accuracy.

We now have now to be careful whereas selecting activation options for each layer. Proper right here we’ve got now used relu for each layer .

Additional on Relu: f(x)=max(0,x)

If output is larger than 0 then neuron is likely to be activated.
Since solely a certain number of neurons are activated, the ReLU is computationally surroundings pleasant

On the hostile facet of the graph, the gradient value is zero. Attributable to this trigger, all through the backpropogation course of, the weights and biases for some neurons mustn’t updated. This might create ineffective neurons which not at all get activated.

model = Sequential()
model.add(Conv2D(16,kernel_size=(3,3),activation='relu',input_shape=X_train[0].kind))
model.add(BatchNormalization())
model.add(MaxPool2D(2,2))
model.add(Dropout(0.2))
model.add(Conv2D(32,kernel_size=(3,3),activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(2,2))
model.add(Dropout(0.3))
model.add(Conv2D(64,kernel_size=(3,3),activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(2,2))
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(512,activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))
model.add(Dense(1024,activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))
model.add(Dense(2,activation='sigmoid'))
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-5)
model.compile(optimizer=optimizer, loss="binary_crossentropy", metrics=["accuracy"])

permit us to compile and start trainning our model.

# teaching the model created
historic previous = model.match(
X_train, 
y_train, 
batch_size=64, 
validation_data=(X_test, y_test), 
verbose=1,
#callbacks=[checkpointer, earlystopping],
shuffle=True,
epochs=150 # improve or decrease epochs primarily based totally on need
)

Proper right here, we’ll improve and cut back the epochs in step with our need. we’ve got now to hint accuracy .

With 5 iterations we’re just about getting 66% of accuracy. Not unhealthy in preliminary stage of model.

We’re going to use historic previous to plot the accuracy on teaching and validation data.

#plotting the graph for the way in which accuracy is varied primarily based totally on epochs
training_acc = historic previous.historic previous["accuracy"]
val_acc = historic previous.historic previous["val_accuracy"]
plt.decide(figsize=(10, 7))
plt.plot(historic previous.epoch, training_acc, label="Teaching Accuracy")
plt.plot(historic previous.epoch, val_acc, label="Validation Accuracy")
plt.xlabel("Epoch")
plt.ylabel("Accuracy of model")
plt.legend()
plt.current()

There’s further on CNN to seek out , we’ve got now barely scratched the ground . On this text we created a CNN model for Bronchial bronchial asthma detection. With preliminary iterations we’d attain 66% accuracy. Observe me for further contents on AI and data science. I hope you most well-liked it. Utterly happy Learning :).