Spaces:
Runtime error
Runtime error
| # coding: utf-8 | |
| __author__ = 'Roman Solovyev (ZFTurbo), IPPM RAS' | |
| if __name__ == '__main__': | |
| import os | |
| gpu_use = "0" | |
| print('GPU use: {}'.format(gpu_use)) | |
| os.environ["CUDA_VISIBLE_DEVICES"] = "{}".format(gpu_use) | |
| import time | |
| import os | |
| import numpy as np | |
| from PyQt5.QtCore import * | |
| from PyQt5 import QtCore | |
| from PyQt5.QtWidgets import * | |
| from PyQt5.QtGui import * | |
| import sys | |
| from inference import predict_with_model, __VERSION__ | |
| import torch | |
| root = dict() | |
| class Worker(QObject): | |
| finished = pyqtSignal() | |
| progress = pyqtSignal(int) | |
| def __init__(self, options): | |
| super().__init__() | |
| self.options = options | |
| def run(self): | |
| global root | |
| # Here we pass the update_progress (uncalled!) | |
| self.options['update_percent_func'] = self.update_progress | |
| predict_with_model(self.options) | |
| root['button_start'].setDisabled(False) | |
| root['button_finish'].setDisabled(True) | |
| root['start_proc'] = False | |
| self.finished.emit() | |
| def update_progress(self, percent): | |
| self.progress.emit(percent) | |
| class Ui_Dialog(object): | |
| def setupUi(self, Dialog): | |
| global root | |
| Dialog.setObjectName("Settings") | |
| Dialog.resize(370, 320) | |
| self.checkbox_cpu = QCheckBox("Use CPU instead of GPU?", Dialog) | |
| self.checkbox_cpu.move(30, 10) | |
| self.checkbox_cpu.resize(320, 40) | |
| if root['cpu']: | |
| self.checkbox_cpu.setChecked(True) | |
| self.checkbox_single_onnx = QCheckBox("Use single ONNX?", Dialog) | |
| self.checkbox_single_onnx.move(30, 40) | |
| self.checkbox_single_onnx.resize(320, 40) | |
| if root['single_onnx']: | |
| self.checkbox_single_onnx.setChecked(True) | |
| self.checkbox_large_gpu = QCheckBox("Use large GPU?", Dialog) | |
| self.checkbox_large_gpu.move(30, 70) | |
| self.checkbox_large_gpu.resize(320, 40) | |
| if root['large_gpu']: | |
| self.checkbox_large_gpu.setChecked(True) | |
| self.checkbox_kim_1 = QCheckBox("Use old Kim Vocal model?", Dialog) | |
| self.checkbox_kim_1.move(30, 100) | |
| self.checkbox_kim_1.resize(320, 40) | |
| if root['use_kim_model_1']: | |
| self.checkbox_kim_1.setChecked(True) | |
| self.checkbox_only_vocals = QCheckBox("Generate only vocals/instrumental?", Dialog) | |
| self.checkbox_only_vocals.move(30, 130) | |
| self.checkbox_only_vocals.resize(320, 40) | |
| if root['only_vocals']: | |
| self.checkbox_only_vocals.setChecked(True) | |
| self.chunk_size_label = QLabel(Dialog) | |
| self.chunk_size_label.setText('Chunk size') | |
| self.chunk_size_label.move(30, 160) | |
| self.chunk_size_label.resize(320, 40) | |
| self.chunk_size_valid = QIntValidator(bottom=100000, top=10000000) | |
| self.chunk_size = QLineEdit(Dialog) | |
| self.chunk_size.setFixedWidth(140) | |
| self.chunk_size.move(130, 170) | |
| self.chunk_size.setValidator(self.chunk_size_valid) | |
| self.chunk_size.setText(str(root['chunk_size'])) | |
| self.overlap_large_label = QLabel(Dialog) | |
| self.overlap_large_label.setText('Overlap large') | |
| self.overlap_large_label.move(30, 190) | |
| self.overlap_large_label.resize(320, 40) | |
| self.overlap_large_valid = QDoubleValidator(bottom=0.001, top=0.999, decimals=10) | |
| self.overlap_large_valid.setNotation(QDoubleValidator.Notation.StandardNotation) | |
| self.overlap_large = QLineEdit(Dialog) | |
| self.overlap_large.setFixedWidth(140) | |
| self.overlap_large.move(130, 200) | |
| self.overlap_large.setValidator(self.overlap_large_valid) | |
| self.overlap_large.setText(str(root['overlap_large'])) | |
| self.overlap_small_label = QLabel(Dialog) | |
| self.overlap_small_label.setText('Overlap small') | |
| self.overlap_small_label.move(30, 220) | |
| self.overlap_small_label.resize(320, 40) | |
| self.overlap_small_valid = QDoubleValidator(0.001, 0.999, 10) | |
| self.overlap_small_valid.setNotation(QDoubleValidator.Notation.StandardNotation) | |
| self.overlap_small = QLineEdit(Dialog) | |
| self.overlap_small.setFixedWidth(140) | |
| self.overlap_small.move(130, 230) | |
| self.overlap_small.setValidator(self.overlap_small_valid) | |
| self.overlap_small.setText(str(root['overlap_small'])) | |
| self.pushButton_save = QPushButton(Dialog) | |
| self.pushButton_save.setObjectName("pushButton_save") | |
| self.pushButton_save.move(30, 280) | |
| self.pushButton_save.resize(150, 35) | |
| self.pushButton_cancel = QPushButton(Dialog) | |
| self.pushButton_cancel.setObjectName("pushButton_cancel") | |
| self.pushButton_cancel.move(190, 280) | |
| self.pushButton_cancel.resize(150, 35) | |
| self.retranslateUi(Dialog) | |
| QtCore.QMetaObject.connectSlotsByName(Dialog) | |
| self.Dialog = Dialog | |
| # connect the two functions | |
| self.pushButton_save.clicked.connect(self.return_save) | |
| self.pushButton_cancel.clicked.connect(self.return_cancel) | |
| def retranslateUi(self, Dialog): | |
| _translate = QtCore.QCoreApplication.translate | |
| Dialog.setWindowTitle(_translate("Settings", "Settings")) | |
| self.pushButton_cancel.setText(_translate("Settings", "Cancel")) | |
| self.pushButton_save.setText(_translate("Settings", "Save settings")) | |
| def return_save(self): | |
| global root | |
| # print("save") | |
| root['cpu'] = self.checkbox_cpu.isChecked() | |
| root['single_onnx'] = self.checkbox_single_onnx.isChecked() | |
| root['large_gpu'] = self.checkbox_large_gpu.isChecked() | |
| root['use_kim_model_1'] = self.checkbox_kim_1.isChecked() | |
| root['only_vocals'] = self.checkbox_only_vocals.isChecked() | |
| chunk_size_text = self.chunk_size.text() | |
| state = self.chunk_size_valid.validate(chunk_size_text, 0) | |
| if state[0] == QValidator.State.Acceptable: | |
| root['chunk_size'] = chunk_size_text | |
| overlap_large_text = self.overlap_large.text() | |
| # locale problems... it wants comma instead of dot | |
| if 0: | |
| state = self.overlap_large_valid.validate(overlap_large_text, 0) | |
| if state[0] == QValidator.State.Acceptable: | |
| root['overlap_large'] = float(overlap_large_text) | |
| else: | |
| root['overlap_large'] = float(overlap_large_text) | |
| overlap_small_text = self.overlap_small.text() | |
| if 0: | |
| state = self.overlap_small_valid.validate(overlap_small_text, 0) | |
| if state[0] == QValidator.State.Acceptable: | |
| root['overlap_small'] = float(overlap_small_text) | |
| else: | |
| root['overlap_small'] = float(overlap_small_text) | |
| self.Dialog.close() | |
| def return_cancel(self): | |
| global root | |
| # print("cancel") | |
| self.Dialog.close() | |
| class MyWidget(QWidget): | |
| def __init__(self): | |
| super().__init__() | |
| self.initUI() | |
| def initUI(self): | |
| self.resize(560, 360) | |
| self.move(300, 300) | |
| self.setWindowTitle('MVSEP music separation model') | |
| self.setAcceptDrops(True) | |
| def dragEnterEvent(self, event): | |
| if event.mimeData().hasUrls(): | |
| event.accept() | |
| else: | |
| event.ignore() | |
| def dropEvent(self, event): | |
| global root | |
| files = [u.toLocalFile() for u in event.mimeData().urls()] | |
| txt = '' | |
| root['input_files'] = [] | |
| for f in files: | |
| root['input_files'].append(f) | |
| txt += f + '\n' | |
| root['input_files_list_text_area'].insertPlainText(txt) | |
| root['progress_bar'].setValue(0) | |
| def execute_long_task(self): | |
| global root | |
| if len(root['input_files']) == 0 and 1: | |
| QMessageBox.about(root['w'], "Error", "No input files specified!") | |
| return | |
| root['progress_bar'].show() | |
| root['button_start'].setDisabled(True) | |
| root['button_finish'].setDisabled(False) | |
| root['start_proc'] = True | |
| options = { | |
| 'input_audio': root['input_files'], | |
| 'output_folder': root['output_folder'], | |
| 'cpu': root['cpu'], | |
| 'single_onnx': root['single_onnx'], | |
| 'large_gpu': root['large_gpu'], | |
| 'chunk_size': root['chunk_size'], | |
| 'overlap_large': root['overlap_large'], | |
| 'overlap_small': root['overlap_small'], | |
| 'use_kim_model_1': root['use_kim_model_1'], | |
| 'only_vocals': root['only_vocals'], | |
| } | |
| self.update_progress(0) | |
| self.thread = QThread() | |
| self.worker = Worker(options) | |
| self.worker.moveToThread(self.thread) | |
| self.thread.started.connect(self.worker.run) | |
| self.worker.finished.connect(self.thread.quit) | |
| self.worker.finished.connect(self.worker.deleteLater) | |
| self.thread.finished.connect(self.thread.deleteLater) | |
| self.worker.progress.connect(self.update_progress) | |
| self.thread.start() | |
| def stop_separation(self): | |
| global root | |
| self.thread.terminate() | |
| root['button_start'].setDisabled(False) | |
| root['button_finish'].setDisabled(True) | |
| root['start_proc'] = False | |
| root['progress_bar'].hide() | |
| def update_progress(self, progress): | |
| global root | |
| root['progress_bar'].setValue(progress) | |
| def open_settings(self): | |
| global root | |
| dialog = QDialog() | |
| dialog.ui = Ui_Dialog() | |
| dialog.ui.setupUi(dialog) | |
| dialog.exec_() | |
| def dialog_select_input_files(): | |
| global root | |
| files, _ = QFileDialog.getOpenFileNames( | |
| None, | |
| "QFileDialog.getOpenFileNames()", | |
| "", | |
| "All Files (*);;Audio Files (*.wav, *.mp3, *.flac)", | |
| ) | |
| if files: | |
| txt = '' | |
| root['input_files'] = [] | |
| for f in files: | |
| root['input_files'].append(f) | |
| txt += f + '\n' | |
| root['input_files_list_text_area'].insertPlainText(txt) | |
| root['progress_bar'].setValue(0) | |
| return files | |
| def dialog_select_output_folder(): | |
| global root | |
| foldername = QFileDialog.getExistingDirectory( | |
| None, | |
| "Select Directory" | |
| ) | |
| root['output_folder'] = foldername + '/' | |
| root['output_folder_line_edit'].setText(root['output_folder']) | |
| return foldername | |
| def create_dialog(): | |
| global root | |
| app = QApplication(sys.argv) | |
| w = MyWidget() | |
| root['input_files'] = [] | |
| root['output_folder'] = os.path.dirname(os.path.abspath(__file__)) + '/results/' | |
| root['cpu'] = False | |
| root['large_gpu'] = False | |
| root['single_onnx'] = False | |
| root['chunk_size'] = 1000000 | |
| root['overlap_large'] = 0.6 | |
| root['overlap_small'] = 0.5 | |
| root['use_kim_model_1'] = False | |
| root['only_vocals'] = False | |
| t = torch.cuda.get_device_properties(0).total_memory / (1024 * 1024 * 1024) | |
| if t > 11.5: | |
| print('You have enough GPU memory ({:.2f} GB), so we set fast GPU mode. You can change in settings!'.format(t)) | |
| root['large_gpu'] = True | |
| root['single_onnx'] = False | |
| elif t < 8: | |
| root['large_gpu'] = False | |
| root['single_onnx'] = True | |
| root['chunk_size'] = 500000 | |
| button_select_input_files = QPushButton(w) | |
| button_select_input_files.setText("Input audio files") | |
| button_select_input_files.clicked.connect(dialog_select_input_files) | |
| button_select_input_files.setFixedHeight(35) | |
| button_select_input_files.setFixedWidth(150) | |
| button_select_input_files.move(30, 20) | |
| input_files_list_text_area = QTextEdit(w) | |
| input_files_list_text_area.setReadOnly(True) | |
| input_files_list_text_area.setLineWrapMode(QTextEdit.NoWrap) | |
| font = input_files_list_text_area.font() | |
| font.setFamily("Courier") | |
| font.setPointSize(10) | |
| input_files_list_text_area.move(30, 60) | |
| input_files_list_text_area.resize(500, 100) | |
| button_select_output_folder = QPushButton(w) | |
| button_select_output_folder.setText("Output folder") | |
| button_select_output_folder.setFixedHeight(35) | |
| button_select_output_folder.setFixedWidth(150) | |
| button_select_output_folder.clicked.connect(dialog_select_output_folder) | |
| button_select_output_folder.move(30, 180) | |
| output_folder_line_edit = QLineEdit(w) | |
| output_folder_line_edit.setReadOnly(True) | |
| font = output_folder_line_edit.font() | |
| font.setFamily("Courier") | |
| font.setPointSize(10) | |
| output_folder_line_edit.move(30, 220) | |
| output_folder_line_edit.setFixedWidth(500) | |
| output_folder_line_edit.setText(root['output_folder']) | |
| progress_bar = QProgressBar(w) | |
| # progress_bar.move(30, 310) | |
| progress_bar.setValue(0) | |
| progress_bar.setGeometry(30, 310, 500, 35) | |
| progress_bar.setAlignment(QtCore.Qt.AlignCenter) | |
| progress_bar.hide() | |
| root['progress_bar'] = progress_bar | |
| button_start = QPushButton('Start separation', w) | |
| button_start.clicked.connect(w.execute_long_task) | |
| button_start.setFixedHeight(35) | |
| button_start.setFixedWidth(150) | |
| button_start.move(30, 270) | |
| button_finish = QPushButton('Stop separation', w) | |
| button_finish.clicked.connect(w.stop_separation) | |
| button_finish.setFixedHeight(35) | |
| button_finish.setFixedWidth(150) | |
| button_finish.move(200, 270) | |
| button_finish.setDisabled(True) | |
| button_settings = QPushButton('⚙', w) | |
| button_settings.clicked.connect(w.open_settings) | |
| button_settings.setFixedHeight(35) | |
| button_settings.setFixedWidth(35) | |
| button_settings.move(495, 270) | |
| button_settings.setDisabled(False) | |
| mvsep_link = QLabel(w) | |
| mvsep_link.setOpenExternalLinks(True) | |
| font = mvsep_link.font() | |
| font.setFamily("Courier") | |
| font.setPointSize(10) | |
| mvsep_link.move(415, 30) | |
| mvsep_link.setText('Powered by <a href="https://mvsep.com">MVSep.com</a>') | |
| root['w'] = w | |
| root['input_files_list_text_area'] = input_files_list_text_area | |
| root['output_folder_line_edit'] = output_folder_line_edit | |
| root['button_start'] = button_start | |
| root['button_finish'] = button_finish | |
| root['button_settings'] = button_settings | |
| # w.showMaximized() | |
| w.show() | |
| sys.exit(app.exec_()) | |
| if __name__ == '__main__': | |
| print('Version: {}'.format(__VERSION__)) | |
| create_dialog() | |