Deep Fake voice recognition

https://github.com/andreanorm/Deep_fake_voice_recognition

.gitignore : git이 관리하지 않는 파일 지정
requirements.txt : 필요한 라이브러리..? 

 

Compare_features_db

#파일 불러오기
elise_feat = pd.read_csv('data/dataset_Elise.csv')
youss_feat = pd.read_csv('data/New_features1.csv')

#columns : DataFrame의 모든 열 이름 반환 
#columns[1:] : 첫번째 열을 제외한 나머지 모든 열 이름 
elise_feat = elise_feat[elise_feat.columns[1:]]

#elise_feat 통계 요약 계산 후 mean, 50%, std 선택 
#round 함수 : 소수점 둘째 자리까지 반올림 
compare_real_df = round(elise_feat.describe().T[['mean','50%','std']],2)
#열 이름 변경 
compare_real_df.rename(columns= {'mean':'v_e_mean','50%':'v_e_50%','std':'v_e_std'},inplace=True)
#youss_feat의 통계 요약 계산 후 mean, 50%, std 열 추가  
#round 함수 : 소수점 둘째 자리까지 반올림 
compare_real_df[['v_y_mean','v_y_50%','v_y_std']] = round(youss_feat.describe().T[['mean','50%','std']],2)
#elise, youss 차이 계산
compare_real_df['delt_mean'] = compare_real_df['v_e_mean'] -compare_real_df['v_y_mean']
compare_real_df['delt_50%'] = compare_real_df['v_e_50%'] -compare_real_df['v_y_50%']
compare_real_df['delt_std'] = compare_real_df['v_e_std'] -compare_real_df['v_y_std']
compare_real_df

파일 두개 불러와서 mean(평균), 50%(중앙값), std(표준편차) 값 차이 계산 

→ 실제 목소리와 기계음 차이 계산 후 비교..? 

 

Convert_voice_to_feature

#라이브러리 import 
import librosa
import soundfile as sf
filename = 'extracted_segment_ryan.wav'
#y : 오디오 시계열 데이터, sr : 샘플링 레이트  
y, sr = librosa.load(filename, sr=None)
#주피터 노트북에서 오디오 파일 실행하는 모듈 
from IPython.display import Audio 

#오디오 실행 
Audio(y,rate=sr)

#오디오 파일에서 다양한 오디오 특징 추출 
def get_features(file_path, file_name):
    y, sr = librosa.load(file_path)
    #오디오 파일 길이를 초 단위로 계산 
    iter_ = int(y.shape[0]/sr)
    features = []
    #오디오 데이터를 1초씩 분할하고 분할된 데이터에 대해 특징 추출 
    for i in range(iter_):
        #반복 횟수 : 오디오 파일의 길이를 초 단위로 계산 
        y_seg = y[i*sr:(sr*i+sr)]
        #크로마 스펙트로그램 평균값 
        chroma_stft = np.mean(librosa.feature.chroma_stft(y=y_seg, sr=sr))
        #Root Mean Square 에너지 평균값 
        rms = np.mean(librosa.feature.rms(y=y_seg))
        #스펙트럼 중심 평균값 
        spec_cent = np.mean(librosa.feature.spectral_centroid(y=y_seg, sr=sr))
        #스펙트럼 대역폭의 평균값 
        spec_bw = np.mean(librosa.feature.spectral_bandwidth(y=y_seg, sr=sr))
        #스펙트럼 롤오프의 평균값 
        rolloff = np.mean(librosa.feature.spectral_rolloff(y=y_seg, sr=sr))
        #제로 크로싱 레이트의 평균값 
        zcr = np.mean(librosa.feature.zero_crossing_rate(y_seg))
        #멜 주파수 켑스트럼 계수의 평균값 20개 
        mfcc = np.mean(librosa.feature.mfcc(y=y_seg, sr=sr, n_mfcc=20),axis=1)
        features.append([chroma_stft,rms,spec_cent,spec_bw,rolloff,zcr,*mfcc]) # starred expressions for mfcc to get 20 columns instead of 20 row
        # b = np.concatenate((b,a),axis=1) # ajout filename apres?
    return features

→ 음성 데이터의 특징 추출 

 

Extract_demonstration

#오디오 및 음악 신호 분석 라이브러리 
import librosa
#오디오 파일 읽기 및 쓰기 
import soundfile as sf
#데이터 시각화 
import matplotlib.pyplot as plt
from IPython.display import Audio
#데이터 조작 및 분석 (데이터프레임)
import pandas as pd
#수치 계산 라이브러리 
import numpy as np 
#파일 및 디렉터리 작업 
import os
import soundfile as sf
#eXtreme Gradient Boosing 알고리즘 라이브러리 
from xgboost import XGBClassifier
#데이터 훈련 및 테스트 세트로 분할, 교차 검증 점수 계산, 하이퍼파라미터 튜닝
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV, RandomizedSearchCV
#레이블 인코딩 
from sklearn.preprocessing import LabelEncoder
#성능 평가 지표 
from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score, auc

#오디오 파일의 특정 구간을 잘라내어 새로운 파일로 저장 
def cut_audio_file(audio_dir_test,file,start,lenght):
# to get the audio segment and save it as segment_lenght_filename.mp3
#file = filename.mp3
# start = seconds
# lenght = seconds
    #오디오 파일 경로 
    filename=os.path.join(audio_dir_test,file)
    #오디오 파일 가져오기 
    y, sr = librosa.load(filename, sr=None)
    # Define start and end times 시작/끝 시간 (시작 시간 이후 length만큼 더한 시간에 끝) 
    end_sec = start + lenght  # 4 seconds after the start
    # Convert times to samples 시간을 샘플로 변환 (초 단위 시간을 샘플 단위로 변환)
    start_sample = int(start * sr)
    end_sample = int(end_sec * sr)
    # Extract the segment 구간 추출 (시작~끝 샘플까지의 데이터 추출) 
    segment = y[start_sample:end_sample]
    # Save the segment 추출한 오디오 구간을 새로운 파일로 저장 
    out_filename = f'extracted_segment_{lenght}_{file}'
    sf.write(os.path.join(audio_dir_test,out_filename), segment, sr)

#Convert_voice_to_feature 함수랑 동일 
#get all features out of giver file 오디오 특징 추출 
def get_features(file_path, file_name):
    y, sr = librosa.load(file_path)
    iter_ = int(y.shape[0]/sr)
    features = []
    for i in range(iter_):
        y_seg = y[i*sr:(sr*i+sr)]
        chroma_stft = np.mean(librosa.feature.chroma_stft(y=y_seg, sr=sr))
        rms = np.mean(librosa.feature.rms(y=y_seg))
        spec_cent = np.mean(librosa.feature.spectral_centroid(y=y_seg, sr=sr))
        spec_bw = np.mean(librosa.feature.spectral_bandwidth(y=y_seg, sr=sr))
        rolloff = np.mean(librosa.feature.spectral_rolloff(y=y_seg, sr=sr))
        zcr = np.mean(librosa.feature.zero_crossing_rate(y_seg))
        mfcc = np.mean(librosa.feature.mfcc(y=y_seg, sr=sr, n_mfcc=20),axis=1)
        features.append([chroma_stft,rms,spec_cent,spec_bw,rolloff,zcr,*mfcc]) # starred expressions for mfcc to get 20 columns instead of 20 row
        # b = np.concatenate((b,a),axis=1) # ajout filename apres?
    return features
    
#DATASET-balanced.csv 파일 불러오기 
data_set = pd.read_csv('Data/DATASET-balanced.csv')

#오디오 파일 추출 후 데이터프레임으로 변환 
def make_test_features_df(audio_dir,filename):
    #get_features 함수 호출해서 오디오 파일 특징 추출 
    file_features=get_features(os.path.join(audio_dir,filename),filename)
    feature_list = []
    #오디오 파일 특징 추출한 값을 feature_list에 추가 
    for segment_features in file_features:
            feature_list.append(segment_features)

    #데이터프레임 생성 (data_set 데이터프레임의 첫번째~마지막에서 두번째 열까지의 이름)
    features_df = pd.DataFrame(feature_list,columns = data_set.columns[0:-1])
    return features_df
    
#Start here : make sure it the right path
#디렉터리 경로에 있는 모든 파일과 디렉토리 이름을 리스트로 반환 
audio_dir_test='data/DEMONSTRATION/DEMONSTRATION'
files = os.listdir(audio_dir_test)
files

#select the file to cut using files[] 5번째 파일만 가져오기 
file_to_cut = files[5]
file_to_cut

#오디오 파일의 특정 구간 자르기 (초 단위) 
#오디오 파일이 저장된 디렉토리, 잘라낼 오디오 파일 이름, 오디오 파일의 시작 위치, 잘라낼 구간의 길이 
#start in second, and the lenght in seconds
cut_audio_file(audio_dir_test,file_to_cut,89,10)

#주어진 디렉토리 내의 모든 파일과 디렉토리 이름 리스트로 반환 
files = os.listdir(audio_dir_test)
files

#0번째 파일 선택 후 저장 
# select file to extract
file_toextract = files[0]
file_toextract

#make_test_features_df 함수 호출 
new_df = make_test_features_df(audio_dir_test,file_toextract)

#files[0]번째 파일명이 저장되어 있는데, 여기서 끝에서 4개의 문자를 제외한 파일 이름 추출 (확장자)
file_toextract[:-4]

#(떼이터프레임 > csv) 확장자를 제외한 파일명에 csv 붙여서 파일 변환시켜서 해당 경로에 생성 
new_df.to_csv(f'data/{file_toextract[:-4]}.csv',index=False)

→ 디렉터리 경로에 있는 모든 파일 가져오기
특정 파일 가져와서 특정 구간의 오디오 특징 추출 후 csv 파일로 변환 

 

Features_youss_Elise parms

#DATASET-balanced.csv 파일 불러오기 
data_set = pd.read_csv('Data/DATASET-balanced.csv')

#chroma_stft 열 선택 후 plot() 사용해서 그래프로 시각화 
data_set.chroma_stft.plot()

#LABEL 열 선택 후 LABEL 열의 각 값이 데이터프레임에 얼마나 자주 나타나는지 계산 
data_set.LABEL.value_counts()

#오디오 파일 가져오기 
#y : 오디오 시계열 데이터 (numpy 배열), sr : 샘플링 레이트 
#sr : 22050 
y, sr = librosa.load('Data/AUDIO/REAL/biden-original.wav') 
plt.plot(y[0:22050])

#오디오 파일에서 MFCCs 추출하여 데이터 프레임으로 변환 
# Calculate the STFT
#오디오의 첫 1초 동안의 단기 푸리에 변환(STFT) 계산 
stft = librosa.stft(y[0:sr])
#STFT 파워 스펙트럼을 Mel 스케일로 변환 
# Map STFT powers to Mel scale using triangular filters
n_mels = 20 #Mel 필터 개수 
mel = librosa.filters.mel(sr=sr,n_fft=2048, n_mels=n_mels)
mel_spec = librosa.feature.melspectrogram(S=np.abs(stft)**2, sr=sr, n_mels=n_mels)
#Mel 스팩트로그램을 데시벨 단위로 변환 
log_mel_spec = librosa.power_to_db(mel_spec, ref=np.max)
#MFCC 계산 : 로그 Mel 스펙트로그램을 사용하여 20개의 MFCC 계산 
# Apply Discrete Cosine Transform (DCT) to obtain MFCCs
n_mfcc = 20
mfcc = librosa.feature.mfcc(S=log_mel_spec, n_mfcc=n_mfcc)
#MFCC를 데이터프레임으로 변환 
test2 = pd.DataFrame(mfcc.T)
test3 = pd.DataFrame(np.mean(mfcc, axis=1).T) #mfcc의 평균값 계산

#librosa.beat.beat_track : 오디오 신호에서 템포, 비트프레임 추출 후 데이터프레임으로 변환 
tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)

#오디오 객체 생성
#rate=sr : 오디오 데이터가 재생될 속도 
Audio(y,rate=sr)

#harmonics, percussives 성분 분리 
#y[0:sr] : 오디오 시계열 데이터의 처음 1초 
y_harmonic, y_percussive = librosa.effects.hpss(y[0:sr])

#librosa.feature.chroma_cqt 함수 : harmonic 신호에서 chroma 특징 계산 
chromagram = librosa.feature.chroma_cqt(y=y_harmonic, sr=sr)

#오디오 신호의 샘플 수를 초 단위로 변환하여 반복 횟수 계산 
#y.shape[0] : 오디오 신호의 전체 샘플 수 반환 
iter_ = int(y.shape[0]/sr)

#오디오 파일을 초 단위로 분할하고 각 분할의 시작 및 끝 샘플 인덱스를 출력 
#iter_ : 오디오 데이터의 길이를 초 단위로 나타낸 값 
#i*sr : 현재 분할의 시작 샘플 인덱스, sr*i+sr : 현재 분할의 끝 샘플 인덱스 
for i in range(iter_):
    print(i*sr,(sr*i+sr))

#지정된 디렉터리에서 파일 목록을 가져와 각 파일의 전체 경로 출력 
audio_dir='data/AUDIO'
label = 'REAL'
files = os.listdir(os.path.join(audio_dir,label)) #audio_dir/label 디렉토리 
#files 리스트 순회하면서 각 파일의 전체 경로 출력 
for file in files:
    print(os.path.join(audio_dir,label,file)) #audio_dir/label/file명 

#지정된 디렉터리 내의 오디오 파일들로부터 특징 추출하여 데이터프레임 생성 
#make dataframe with all the features
def make_features_df(audio_dir):
    #오디오 파일들이 REAL, FAKE 폴더에 분리되어 있다고 가정하고 레이블들을 리스트 ㅔ저장 
    labels = ['REAL','FAKE'] 
    feature_list = []
    #레이블별 해당 폴더 내의 파일 목록 가져와서 get_feature 함수를 통해 특징 추출 
    for label in labels:
        files = os.listdir(os.path.join(audio_dir, label))
        for file in files:
            file_features=get_features(os.path.join(audio_dir,label,file),file)
            for segment_features in file_features:
                    feature_list.append(segment_features + [label])

    #data_set.columns 사용하여 데이터프레임의 열 이름 설정 
    features_df = pd.DataFrame(features,columns = data_set.columns)
    return features_df
    
complete_df= pd.read_csv('data/New_features.csv')
data_set = pd.read_csv('Data/DATASET-balanced.csv')

#complete_df 데이터프레임을 REAL, FAKE 레이블로 분리하고 data_set 데이터프레임을 로드하여 나머지 데이터프레임 생성 
real_df = complete_df[complete_df['LABEL'] == 'REAL'][complete_df.columns[1:]]
fake_df = complete_df[complete_df['LABEL'] == 'FAKE'][complete_df.columns[1:]]

#data_set의 LABEL이 REAL인 행만 가져오기 
real_df_o = data_set[data_set['LABEL'] == 'REAL'][data_set.columns]

#데이터프레임 비교 
compare_real_df = round(real_df.describe().T[['mean','50%','std']],2)
compare_real_df.rename(columns= {'mean':'v_1_mean','50%':'v_1_50%','std':'v_1_std'},inplace=True)
#real_df_o의 통계 요약 계산 후 compare_real_df에 추가 
compare_real_df[['v_o_mean','v_o_50%','v_o_std']] = round(real_df_o.describe().T[['mean','50%','std']],2)

#fake_df 데이터프레임 주요 통계치 계산 후 반올림하여 출력 
# round(real_df.describe().T[['mean','50%','std']],2)
round(fake_df.describe().T[['mean','50%','std']],2)

→ Mel 스펙트로그램 특징 추출

 

XGBoost 

n_estimators : 부스팅 과정에서 생성할 트리 수 

#분류 모델 
from xgboost import XGBClassifier
#모델 선택 및 검증 도구 
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV, RandomizedSearchCV
#레이블 인코딩 및 성능 평가 지표 
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score, auc
#랜덤 포레스트 분류기
from sklearn.ensemble import RandomForestClassifier

#train_test_split() : complete_df 데이터프레임을 training, test(0.3)용 데이터프레임으로 분할 
#stratify 매개변수 사용하여 레이블 비율 유지하면서 데이터 분할 
df_train, df_test = train_test_split(complete_df, test_size=0.3,stratify=complete_df['LABEL'])

#df_test의 LABEL 열 값의 빈도수 계산 
count = df_train['LABEL'].value_counts()
#count 시리즈에서 두번째 레이블의 빈도수를 real_count에 저장
real_count = count.iloc[1]

#FAKE 레이블을 가진 데이터를 REAL 레이블 개수와 같게 무작위 언더샘플링 진행 > 학습 데이터프레임의 균형 맞추기 
fake_under_sampled = df_train[df_train['LABEL']=='FAKE'].sample(real_count)
#axis=0 : 행 방향으로 병합 
balanced_df = pd.concat([fake_under_sampled, df_train[df_train['LABEL']=='REAL']], axis=0)
balanced_df['LABEL'].value_counts()

#데이터 분리 
#균형 잡힌 학습 데이터와 테스트 데이터를 특징(X)와 레이블(y)로 분리한다. 
#balanced_df에서 마지막 열을 제외한 모든 열 선택 : 학습 데이터 특징 
X_train = balanced_df[balanced_df.columns[0:-1]]
#df_test에서 balanced_df의 마지막 열을 제외한 모든 열 선택 : 테스트 데이터 특징 
X_test = df_test[balanced_df.columns[0:-1]]
#학습 데이터 레이블 분리 
y_label = balanced_df['LABEL']
y_label_test = df_test['LABEL']

레이블 인코더 생성 및 학습 
le = LabelEncoder()
le.fit(y_label) #fit 메소드 사용하여 y_label 데이터 학습 
#transform 메소드 사용하여 y_label 데이터 인코딩 
y_train = le.transform(y_label)
y_test = le.transform(y_label_test)
#인코딩된 값들을 원래 레이블로 변환 le.inverse_transform([0, 0, 1, 2])

#LabelEncoder 객체가 학습한 클래스 목록 확인 
le.classes_

#XGBClassifier사용하여 XGBoost 분류 모델 인스턴스화  
model_xgb = XGBClassifier(max_depth=8,       #트리의 최대 높이 
                         n_estimators=350,   #부스팅 과정에서 생성할 트리 수 
                         learning_rate=0.3)  #각 부스팅 단계에서 가중치를 줄이는 비율 (학습률)
                         
#10겹(cv 값) 교차 검증을 통해 X_train 데이터셋에서 model_xgb 모델의 정확도 평가 
score_accuracy = cross_val_score(model_xgb,X_train,y_train,cv=10,scoring='accuracy')

#model_xgb 모델을 학습 데이터로 학습시키고 테스트 데이터에 대해 예측 값 생성 (y_pred)
model_xgb.fit(X_train,y_train)
y_pred = model_xgb.predict(X_test)

#예측된 값과 실제 값 비교하여 모델 정확도 계산 
accuracy = accuracy_score(y_test,y_pred)

#예측된 값과 실제 값 비교하여 모델의 F1 점수 계산 
f1 = f1_score(y_test,y_pred)

#예측된 값과 실제 값 비교하여 모델의 recall 점수 계산 
#recall : 실제 양성 샘플을 얼마나 잘 식별했는지 (민감도)
recall = recall_score(y_test,y_pred)

#예측된 값과 실제 값 비교하여 모델의 precision 점수 계산 
#precision : 모델이 양성으로 예측한 샘플 중 실제 양성 샘플의 비율 
precision = precision_score(y_test,y_pred)

#그리드 서치를 통한 최적 하이퍼파라미터 탐색 
#하이퍼파라미터 그리드 설정 
param_grid =  {
    'max_depth': range(3,15),
    'learning_rate': [0.001, 0.01, 0.1, 0.2, 0.3],
    'n_estimators' : [200,250,300,350,400,450,500]
}
#GridSearchCV 설정 
search_XGB = GridSearchCV(
    XGBClassifier(),      
    param_grid=param_grid,
    cv=5,  #5겹 교차 검증 
    n_jobs=-1,  #모든 CPU 코어를 사용하여 병렬 처리 수행 
    verbose=1,  
    scoring='precision' #정밀도를 평가 기준으로 설정 
)
#모델 학습 및 최적 하이퍼파라미터 탐색 
search_XGB.fit(X_train, y_train)
#최적화 된 XGBoost 모델 추출 
svm_XGB_best = search_XGB.best_estimator_

#XGBoost 분류기에서 사용할 수 있는 다양한 설정 옵션 
base_score=None, booster=None, callbacks=None,
              colsample_bylevel=None, colsample_bynode=None,
              colsample_bytree=None, device=None, early_stopping_rounds=None,
              enable_categorical=False, eval_metric=None, feature_types=None,
              gamma=None, grow_policy=None, importance_type=None,
              interaction_constraints=None, learning_rate=0.2, max_bin=None,
              max_cat_threshold=None, max_cat_to_onehot=None,
              max_delta_step=None, max_depth=3, max_leaves=None,
              min_child_weight=None, missing=nan, monotone_constraints=None,
              multi_strategy=None, n_estimators=500, n_jobs=None,
              num_parallel_tree=None, random_state=None, ...)

#cross_val_score : 교차검증 사용하여 모델 성능 평가 
score_grid_accuracy = cross_val_score(svm_XGB_best,X_train,y_train,cv=10,scoring='accuracy')

#교차 검증을 통한 정밀도 평가 
score_grid_precision = cross_val_score(svm_XGB_best,X_train,y_train,cv=10,scoring='precision')

#교차 검증을 통한 리콜 평가 
score_grid_recall = cross_val_score(svm_XGB_best,X_train,y_train,cv=10,scoring='recall')

#최적화된 XGBoost 모델을 사용하여 학습 데이터 모델로 재학습시키고 테스트 데이터에 대한 예측 수행 
svm_XGB_best.fit(X_train,y_train)
#y_pred_test : 예측된 레이블 값 
y_pred_best = svm_XGB_best.predict(X_test)
#최적화된 XGBoost 사용하여 테스트 데이터에 대한 정확도 평가 
accuracy2 = accuracy_score(y_test,y_pred_best)
#최적화된 XGBoost 사용하여 테스트 데이터에 대한 리콜 점수 계산 
recall_score(y_test,y_pred_best)
#최적화된 XGBoost 모델 사용하여 테스트 데이터에 대한 F1 점수 계산 
f12 = f1_score(y_test,y_pred_best)
#정밀도 점수 계산 
precision2 = precision_score(y_test,y_pred_best)

#새로운 모델 인스턴스화 
model_xgb = XGBClassifier(max_depth=10, #트리 최대 깊이
                         n_estimators=300,  #부스팅 단계 수
                         learning_rate=0.1) #학습률

 

Random Forest 

테스트 데이터 추가 

#오디오 파일 경로 
audio_dir_test='data/'
files = os.listdir(audio_dir_test)

#이진 레이블 생성 : 각각 1000개의 1과 0으로 구성된 numpy 배열 생성 
y_real = np.ones((1000,))
y_fake = np.zeros((1000,))

#모델 클래스 확인 
svm_XGB_best.classes_

#최적화된 XGBoost 모델 사용하여 새로운 데이터에 대한 예측 및 정확도 계산
pred = svm_XGB_best.predict(new_test_taylor_r)
accuracy_score(y_real[:len(pred)],pred)

#new_test_yf3 데이터프레임의 요약 통계 반환
new_test_yf3.describe().T

 

Features_youss_split_beforebal

#test2에서 new_df에 포함된 값들의 개수 세기 
test2.isin(new_df).sum()

#test2 각 요소가 data_set에 존재하는지 확인 
test2.isin(data_set)

→ 오디오 파일에서 MFCCs 추출
오디오 신호에서 템포, 비트 프레임 추출 

harmonic 신호에서 chroma 특징 계산 
오디오 신호의 샘플 수를 초 단위로 변환하여 반복 횟수 계산 
오디오 파일을 초 단위로 분할하고 각 분할 시작, 끝 샘플 인덱스 출력 
오디오 파일에서 다양한 오디오 특징값 추출
지정된 디렉터리에서 파일 목록 가져와 각 파일의 전체 경로 출력 
지정된 디렉터리 내의 오디오 파일들로부터 특징 추출하여 데이터프레임 생성 

다시 csv 파일 가져오기 
complete_df를 REAL, FAKE 레이블로 분리하고 data_set 로드하여 나머지 데이터프레임 생성
real_df랑 real_df_o(LABEL이 REAL인 데이터) 비교 

 

XGBoost, RandomForest 모델 사용 

 

XGBoost_model

#필요한 모듈, 라이브러리 import

#y : LABEL 열저장
#X : LABEL 열 제거한 나머지 데이터 저장
df = pd.read_csv('raw_data/archive/KAGGLE/DATASET-balanced.csv')
y= df[['LABEL']]
X= df.drop('LABEL', axis=1)

#fit_transform : 레이블 데이터를 숫자로 변환 
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
y=le.fit_transform(y)

#Grid Search 사용해서 XGBoost 모델의 최적 하이퍼파라미터 찾기 
#훈련:테스트 = 7:3
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=42)

grid = {'n_estimators': randint(1, 400), #무작위로 선택할 범위 설정 
        'max_depth': randint(1, 13),  
        'learning_rate': loguniform (0.001, 10)
       }
#XGBoost 모델 인스턴스 생성 
bst = XGBClassifier()
#RandomizedSearchCV 인스턴스 생성 
search = RandomizedSearchCV(
    bst,
    grid, 
    scoring='accuracy',
    n_iter=1000,  
    cv=5, n_jobs=-1
)
#모델 학습 및 최적 하이퍼파라미터 탐색 
search.fit(X_train, y_train)
search.best_estimator_

grid = {'n_estimators': range(320, 360),
        'max_depth': range(4,7),  
        'learning_rate': [0.2, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28]
       }
bst = XGBClassifier()
# Instantiate Grid Search
search = GridSearchCV(
    bst,
    grid, 
    scoring='accuracy',
    cv=5, n_jobs=-1
)
search.fit(X_train, y_train)
search.best_estimator_

#하이퍼파라미터 그리드 설정 
grid = {'n_estimators': range(320, 360),
        'max_depth': range(4,7),  
        'learning_rate': [0.2, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28]
       }
bst = XGBClassifier()
# Instantiate Grid Search
search = GridSearchCV(
    bst,
    grid, 
    scoring='accuracy',
    cv=5, n_jobs=-1
)
search.fit(X_train, y_train)
search.best_estimator_

#모델 설정 및 데이터 분할 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=42)
bst = XGBClassifier(n_estimators=347, max_depth=6, learning_rate=0.22311250284899017, objective='binary:logistic')

#XGBoost 모델 학습, 테스트 데이터 예측 수행 
bst.fit(X_train, y_train)
preds = bst.predict(X_test)

#성능 평가 
accuracy = accuracy_score(y_test, preds)
print(f"Accuracy: {accuracy * 100.0}%")
print('Precision =', round(precision_score(y_test, preds), 6)) # Precision
print('Recall =', round(recall_score(y_test, preds), 6)) # Recall
print('F1 score =', round(f1_score(y_test, preds), 6)) # F1 score

#랜덤 포레스트 교차 검증 
from sklearn.ensemble import RandomForestClassifier
forest = RandomForestClassifier(n_estimators=100)
cv_results = cross_validate(forest, X_train, y_train, scoring = "accuracy", cv=5)

cv_results['test_score'].mean()

#GridSearchCV 사용해서 랜덤 포레스트 분류기의 n_estimators 하이퍼파라미터 최적화 
grid = {'n_estimators': range(0,100)}
search = GridSearchCV(
    forest,
    grid, 
    scoring='accuracy',
    cv=5, n_jobs=-1
)
#모델 학습 및 최적 하이퍼파라미터 탐색
search.fit(X_train, y_train)
search.best_estimator_

#랜덤 포레스트 모델 설정 
forest = RandomForestClassifier(n_estimators=99)
#모델 학습 및 예측 수행 
forest.fit(X_train, y_train)
pred_forest = forest.predict(X_test)
#성능 평가 
accuracy = accuracy_score(y_test, pred_forest)
print(f"Accuracy: {accuracy * 100.0}%")
print('Precision =', round(precision_score(y_test, pred_forest), 6)) # Precision
print('Recall =', round(recall_score(y_test, pred_forest), 6)) # Recall
print('F1 score =', round(f1_score(y_test, pred_forest), 6)) # F1 score

#오디오 파일의 특정 구간 추출 후 저장 
import librosa
import soundfile as sf
#오디오 파일 로드
filename = 'raw_data/archive/KAGGLE/AUDIO/Ryan Gosling interview.wav'
y, sr = librosa.load(filename, sr=None)
#시작 및 종료 시간 설정 (초 단위)
start_sec = 2 * 60  # 2 minutes
end_sec = start_sec + 4  # 4 seconds after the start
#시간 샘플로 변환 
start_sample = int(start_sec * sr)
end_sample = int(end_sec * sr)
#구간 추출 
segment = y[start_sample:end_sample]
#구간 저장 
out_filename = 'extracted_segment_ryan.wav'
sf.write(out_filename, segment, sr)

 

코드 실행 

 

• compare_features_db : 파일 두개 불러와서 값 비교 (features_youss_elise parms 코드랑 동일)
• convert_voice_to_feature : 음성 데이터의 특징 추출
• extract_demonstration : 디렉터리 경로에 있는 모든 파일 가져오기 → 특정 파일 가져와서 특정 구간의 오디오 특징 추출 후 csv 파일로 변환 
• features_youss_elise parms : Mel 스펙트로그램 특징 추출 + XGBoost, RandomForest(오디오 파일에서 MFCCs 추출) 모델 코드
• XGBoost_model

 

실행 순서 (임의로 생각해본 거..)

1. Convert_voice_to_feature 
   특징 추출한 값을 csv 파일에 저장할 수 있도록 함
2. extract_demonstration
   파일안에 있는 오디오 파일의 특징 추출 → 1번 파일 하나만, 2번은 디렉터리 내의 파일
3. compare_features_db 
   파일 두개 불러와서 값 비교
4. features_youss_elise parms, XGBoost_model
   모델 돌려보기 

 

작년 PBL 코드 

https://colab.research.google.com/drive/1Cy0Vrm7WmjyvXzd7w-8F-74JDGcQI7wB?authuser=0#scrollTo=gu53WAT9CwmG

https://github.com/daeun6/2023-Graduation-products-DeepCaptcha?tab=readme-ov-file