Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· OpenAIHugging Face Arena Human Preference 55K

O que esse código faz na pratica? (Responda em no máximo 50 palavras) [code]

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Mistralmixtral-8x7b-instruct-v0.1’s answer.
  1. User

    O que esse código faz na pratica? (Responda em no máximo 50 palavras)

    import os
    import sys
    import numpy as np
    import soundfile as sf
    from PIL import Image
    import pystray
    from PyQt5.QtWidgets import (QApplication, QWidget, QVBoxLayout, QPushButton,
                                 QLabel, QFileDialog, QDesktopWidget, QScrollArea,
                                 QTableWidget, QTableWidgetItem, QHeaderView,
                                 QAbstractItemView)
    from PyQt5.QtCore import pyqtSlot, QThread, pyqtSignal, Qt
    from pydub import AudioSegment
    
    
    class SDRThread(QThread):
        sdr_calculated = pyqtSignal(list)
    
        def __init__(self, app):
            super().__init__()
            self.app = app
    
        def run(self):
            self.app.inverter_fase_e_mixar()
            sdr_results = self.app.update_and_calculate_sdr()
            self.sdr_calculated.emit(sdr_results)
    
    
    class App(QWidget):
    
        def __init__(self):
            super().__init__()
            self.title = 'SDR Calculator'
            self.reference_file = os.path.join('C:\\Users\\lucas\\Downloads\\', 'vocals.wav')
            self.mixture_file = os.path.join('C:\\Users\\lucas\\Downloads\\', 'mixture.wav')
            self.generated_files = []
            self.initUI()
    
        def initUI(self):
            self.setup_window()
            self.setup_styles()
            self.setup_layout()
            self.setup_widgets()
            self.check_and_select_files()
            self.show()
            self.showMaximized()
    
            self.sdr_thread = SDRThread(self)
            self.sdr_thread.sdr_calculated.connect(self.on_sdr_calculated)
            self.start_sdr_thread()
    
        def setup_window(self):
            self.setWindowTitle(self.title)
            screen_resolution = QDesktopWidget().screenGeometry()
            window_width = 920 + 532 + 350 + 50  # Adjust window width to accommodate total column size
            window_height = screen_resolution.height() // 4
            self.setGeometry(
                screen_resolution.width() // 2 - window_width // 2,
                screen_resolution.height() // 2 - window_height // 2,
                window_width,
                window_height
            )
    
        def setup_styles(self):
            self.setStyleSheet("""
                QWidget {
                    background-color: black;
                }
                QLabel {
                    color: white;
                    font-size: 30px;
                }
                QPushButton {
                    background-color: #555555;
                    color: white;
                    font-size: 30px;
                    padding: 15px;
                    border: 3px solid #555555;
                    border-radius: 15px;
                }
                QPushButton:hover {
                    background-color: #777777;
                }
                QTableWidget {
                    color: white;
                    font-size: 38px;
                }
                QHeaderView::section {
                    color: white;
                    font-size: 38px;
                    background-color: #333333;
                    padding: 5px;
                    border: 1px solid #555555;
                }
                QTableWidget::item {
                    border: 1px solid #dddddd;
                    padding: 8px;
                }
            """)
    
        def setup_layout(self):
            layout = QVBoxLayout()
            layout.setSpacing(25)
            layout.setContentsMargins(25, 25, 25, 25)
            self.setLayout(layout)
    
        def setup_widgets(self):
            self.setup_table()
            self.setup_button()
            self.setup_scroll_area()
    
        def setup_table(self):
            self.table = QTableWidget(0, 3, self)
            self.table.setHorizontalHeaderLabels(["MODELO", "SDR", "SUPERIORIDADE"])
            self.table.setColumnWidth(0, 840)
            self.table.setColumnWidth(1, 530)
            self.table.setColumnWidth(2, 476)
            self.table.verticalHeader().setDefaultSectionSize(50 + 12)  # Adjust row height by adding 14 pixels (approximately 0.5 cm)
            self.table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)  # Add this line to remove horizontal scroll bar
    
            self.table.verticalHeader().setVisible(False)  # Add this line to remove column of numbers (indices)
    
            # Add the following lines
            self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
            self.table.setSelectionMode(QAbstractItemView.NoSelection)
            self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)  # Disable cell editing
            self.table.setFocusPolicy(Qt.NoFocus)  # Remove table focus
    
        def setup_button(self):
            self.button4 = QPushButton('Calcular SDR', self)
            self.button4.clicked.connect(self.start_sdr_thread)
    
        def setup_scroll_area(self):
            scroll_area = QScrollArea(self)
            scroll_area.setWidgetResizable(True)
            scroll_widget = QWidget()
            scroll_area.setWidget(scroll_widget)
    
            scroll_layout = QVBoxLayout()
            scroll_widget.setLayout(scroll_layout)
    
            scroll_layout.addWidget(self.table)
            scroll_layout.addWidget(self.button4)
    
            self.layout().addWidget(scroll_area)
    
        def start_sdr_thread(self):
            if not self.sdr_thread.isRunning():
                self.sdr_thread.start()
    
        def on_sdr_calculated(self, sdr_results):
            self.table.setRowCount(len(sdr_results))
            for i, (filename, sdr, superiority, sdr_difference) in enumerate(sdr_results):
                filename_without_extension = os.path.splitext(filename)[0]
                self.table.setItem(i, 0, QTableWidgetItem(filename_without_extension))
                self.table.setItem(i, 1, QTableWidgetItem(f"{sdr:.3f}"))
    
                # Verifica se é a linha "REFERENCIA" ou o primeiro modelo
                if i == 0 or i == 1:
                    self.table.setItem(i, 2, QTableWidgetItem("                    |        "))  # Adiciona "|" com espaços em branco à célula
                else:
                    # Verifica o número de dígitos da porcentagem para ajustar o espaçamento
                    if superiority >= 10.0:  # 4 dígitos (incluindo o ponto decimal)
                        space_padding = "      |     "
                    else:  # 3 dígitos (incluindo o ponto decimal)
                        space_padding = "        |     "
                    self.table.setItem(i, 2, QTableWidgetItem(f" {superiority:.2f} %{space_padding}-{sdr_difference:.2f} dB"))
    
        @pyqtSlot()
        def update_and_calculate_sdr(self):
            self.select_generated_files()
            return self.calculate_sdr()
    
        def inverter_fase_e_mixar(self):
            def inverter_fase(audio):
                return audio.invert_phase()
    
            def mixar_arquivos(audio1, audio2):
                return audio1.overlay(audio2)
    
            diretorio = "C:\\Users\\lucas\\Downloads"
            arquivo_mixture = "C:\\Users\\lucas\\Downloads\\mixture.wav"
    
            mixture = AudioSegment.from_wav(arquivo_mixture)
    
            for arquivo in os.listdir(diretorio):
                if arquivo.endswith(".wav") and arquivo != "mixture.wav":
                    arquivo_path = os.path.join(diretorio, arquivo)
                    audio = AudioSegment.from_wav(arquivo_path)
    
                    audio_invertido = inverter_fase(audio)
                    audio_mixado = mixar_arquivos(audio_invertido, mixture)
    
                    audio_mixado.export(arquivo_path, format="wav")
    
            print("Fase invertida e mixagem concluídas.")
    
        def calculate_sdr(self):
            reference, _ = sf.read(self.reference_file)
            mixture, _ = sf.read(self.mixture_file)
    
            references = np.expand_dims(reference, axis=0)
            mixtures = np.expand_dims(mixture, axis=0)
    
            reference_sdr = self.calculate_reference_sdr(references)[0]
            sdr_results = [("REFERENCIA", reference_sdr, 0, 0)]
    
            sdr_scores = []
            for generated_file in self.generated_files:
                generated_sdr = self.calculate_generated_sdr(generated_file, references)
                if generated_sdr is not None:
                    sdr_scores.append(generated_sdr)
    
            sdr_scores.sort(key=lambda x: x[1], reverse=True)
    
            for filename, sdr in sdr_scores:
                superiority_percentage = ((sdr_scores[0][1] - sdr) / sdr) * 100
                sdr_difference = sdr_scores[0][1] - sdr
                sdr_results.append((os.path.basename(filename), sdr, round(superiority_percentage, 2), round(sdr_difference, 3)))
    
            return sdr_results
    
        def sdr(self, references, estimates):
            delta = 1e-7
            num = np.sum(np.square(references), axis=(1, 2))
            den = np.sum(np.square(references - estimates), axis=(1, 2))
            num += delta
            den += delta
            return 10 * np.log10(num / den)
    
        def calculate_generated_sdr(self, est, references):
            estimate, _ = sf.read(est)
            estimates = np.expand_dims(estimate, axis=0)
            if estimates.shape != references.shape:
                return None
            song_score_estimate = self.sdr(references, estimates)[0]
            return (est, song_score_estimate)
    
        def calculate_reference_sdr(self, references):
            delta = 1e-7
            num = np.sum(np.square(references), axis=(1, 2))
            den = np.sum(np.square(references - references), axis=(1, 2))
            num += delta
            den += delta
            return 10 * np.log10(num / den)
    
        def check_and_select_files(self):
            if os.path.exists(self.reference_file) and os.path.exists(self.mixture_file):
                self.select_generated_files()
    
        def select_generated_files(self):
            generated_files_dir = 'C:\\Users\\lucas\\Downloads'
            exclude_files = ['vocals.wav', 'other.wav', 'mixture.wav']
            audio_extensions = ['.wav', '.flac', '.mp3', '.ogg']
            self.generated_files = [os.path.join(generated_files_dir, f) for f in os.listdir(generated_files_dir) if f not in exclude_files and os.path.isfile(os.path.join(generated_files_dir, f)) and os.path.splitext(f)[1].lower() in audio_extensions]
    
    
    def on_activate(icon, item):
        icon.stop()
        app.exec_()
    
    def create_icon(icon_path):
        image = Image.open(icon_path)
        icon = pystray.Icon("name", image, "SDR", menu=pystray.Menu(pystray.MenuItem('Abrir', on_activate)))
        icon.run()
    
    if __name__ == '__main__':
        app = QApplication(sys.argv)
        ex = App()
    
        icon_path = "C:\\Users\\lucas\\Downloads\\Scripts\\ico.ico"
        create_icon(icon_path)
    
  2. Assistant

    Esse código é uma aplicação GUI em Python para calcular a Signal-to-Distortion Ratio (SDR) de arquivos de áudio. Ele compara uma faixa de referência com várias faixas geradas, utilizando a biblioteca PyQt5 para a interface gráfica e outras bibliotecas para processamento de áudio. A aplicação inverte a fase e mistura faixas de áudio, calcula o SDR e exibe os resultados em uma tabela.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.