Ошибка импорта в PyTorch

У меня ошибка C:\Users\Admin\PycharmProjects\pythonProject2\venv\Scripts\python.exe C:\Users\Admin\PycharmProjects\pythonProject2\main.py
Traceback (most recent call last):
File "C:\Users\Admin\PycharmProjects\pythonProject2\main.py", line 2, in <module>
import torch.nn as nn
File "C:\Users\Admin\PycharmProjects\pythonProject2\venv\lib\site-packages\torch\nn\__init__.py", line 2, in <module>
from .modules import * # noqa: F403
File "C:\Users\Admin\PycharmProjects\pythonProject2\venv\lib\site-packages\torch\nn\modules\__init__.py", line 1, in <module>
from .module import Module
File "C:\Users\Admin\PycharmProjects\pythonProject2\venv\lib\site-packages\torch\nn\modules\module.py", line 9, in <module>
from torch._prims_common import DeviceLikeType
File "C:\Users\Admin\PycharmProjects\pythonProject2\venv\lib\site-packages\torch\_prims_common\__init__.py", line 36, in <module>
from torch import sym_float, sym_int, sym_max
ImportError: cannot import name 'sym_float' from 'torch' (unknown location)

Process finished with exit code 1



import torch
import torch.nn as nn
import torch.optim as optim
import torchaudio
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import os
import numpy as np
from torch.utils.data import DataLoader, Dataset
from tqdm import tqdm
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import threading
import librosa
from sklearn.decomposition import NMF
import math

# Проверка наличия CUDA
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


class GELUActivation(nn.Module):
def forward(self, x):
return 0.5 * x * (1 + torch.tanh(
math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))
))


class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)

pe = torch.zeros(max_len, d_model)
position = torch.arange(
0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(
0, d_model, 2).float() * (-math.log(10000.0) / d_model)
)
pe[:, 0::2] = torch.sin(position * div_term) # Четные индексы
pe[:, 1::2] = torch.cos(position * div_term) # Нечетные индексы
pe = pe.unsqueeze(0) # Форма (1, max_len, d_model)
self.register_buffer('pe', pe)

def forward(self, x):
x = x + self.pe[:, :x.size(1)]
return self.dropout(x)


class ImprovedTransformerEncoderLayer(nn.Module):
def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1):
super(ImprovedTransformerEncoderLayer, self).__init__()
self.self_attn = nn.MultiheadAttention(
d_model, nhead, dropout=dropout, batch_first=True
)
self.linear1 = nn.Linear(d_model, dim_feedforward)
self.dropout = nn.Dropout(dropout)
self.linear2 = nn.Linear(dim_feedforward, d_model)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
self.activation = GELUActivation()

def forward(self, src, src_mask=None, src_key_padding_mask=None, is_causal=False):
src2 = self.self_attn(
src, src, src, attn_mask=src_mask,
key_padding_mask=src_key_padding_mask, need_weights=False, is_causal=is_causal
)[0]
src = src + self.dropout1(src2)
src = self.norm1(src)
src2 = self.linear2(
self.dropout(self.activation(self.linear1(src)))
)
src = src + self.dropout2(src2)
src = self.norm2(src)
return src


class ImprovedTransformerModel(nn.Module):
def __init__(
self, input_size, output_size, d_model=512, nhead=8, num_layers=6, dropout=0.1
):
super(ImprovedTransformerModel, self).__init__()
self.embedding = nn.Linear(input_size, d_model)
self.pos_encoder = PositionalEncoding(d_model, dropout)
encoder_layer = ImprovedTransformerEncoderLayer(
d_model, nhead, dim_feedforward=2048, dropout=dropout
)
self.transformer_encoder = nn.TransformerEncoder(
encoder_layer, num_layers
)
self.decoder = nn.Linear(d_model, output_size)
self.init_weights()

def init_weights(self):
initrange = 0.1
nn.init.uniform_(self.embedding.weight, -initrange, initrange)
nn.init.zeros_(self.embedding.bias)
nn.init.zeros_(self.decoder.bias)
nn.init.uniform_(self.decoder.weight, -initrange, initrange)

def forward(self, src, src_mask=None, src_key_padding_mask=None):
src = self.embedding(src)
src = self.pos_encoder(src)
output = self.transformer_encoder(
src, mask=src_mask, src_key_padding_mask=src_key_padding_mask)
output = self.decoder(output)
return output


def load_audio(file_path):
waveform, sample_rate = torchaudio.load(file_path)
return waveform, sample_rate


def extract_features(y, sr):
# Извлечение различных признаков
mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20)
chroma = librosa.feature.chroma_stft(y=y, sr=sr)
spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
spectral_contrast = librosa.feature.spectral_contrast(y=y, sr=sr)
spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)

# Объединение всех признаков
features = np.concatenate(
[mfcc, chroma, spectral_centroid, spectral_contrast, spectral_rolloff], axis=0
)

return features.T # Транспонирование для получения формы (время, признаки)


def preprocess_audio(waveform, sample_rate, target_sample_rate=22050):
# Изменение частоты дискретизации при необходимости
if sample_rate != target_sample_rate:
waveform = torchaudio.functional.resample(
waveform, sample_rate, target_sample_rate
)
# Не преобразуем в моно, работаем со всеми каналами
# Форма waveform: (каналы, сэмплы)

# Преобразуем в numpy массив
y = waveform.numpy()

# Извлекаем признаки для каждого канала
features = []
for channel in range(y.shape[0]):
channel_data = y[channel]
channel_features = extract_features(channel_data, target_sample_rate)
features.append(channel_features) # (время, признаки)

# Объединяем признаки по последнему измерению (время, признаки * каналы)
features = np.concatenate(features, axis=1)

# Преобразуем в тензор и нормализуем
features = torch.FloatTensor(features)
features = features / torch.max(torch.abs(features))

return features # Форма (время, признаки)


class MusicDataset(Dataset):
def __init__(self, file_paths, target_sample_rate=22050):
self.file_paths = file_paths
self.target_sample_rate = target_sample_rate
self.data = []
for file_path in file_paths:
try:
waveform, sample_rate = load_audio(file_path)
features = preprocess_audio(
waveform, sample_rate, target_sample_rate
)
self.data.append(features)
except Exception as e:
print(f"Ошибка при обработке {file_path}: {str(e)}")
if not self.data:
raise ValueError("Не найдено подходящих данных.")

def __len__(self):
return len(self.data)

def __getitem__(self, idx):
features = self.data[idx]
input_seq = features[:-1, :] # Все кроме последнего временного шага
target_seq = features[1:, :] # Все кроме первого временного шага
return input_seq, target_seq


def train_model(model, train_loader, val_loader, epochs=100, lr=0.001):
criterion = nn.MSELoss()
optimizer = optim.AdamW(
model.parameters(), lr=lr, betas=(0.9, 0.999),
eps=1e-8, weight_decay=0.01
)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)

best_val_loss = float('inf')
best_model = None
train_losses = []
val_losses = []

for epoch in range(epochs):
model.train()
total_loss = 0
progress_bar = tqdm(train_loader, desc=f"Эпоха {epoch+1}/{epochs}")
for inputs, targets in progress_bar:
optimizer.zero_grad()
inputs, targets = inputs.to(device), targets.to(device)
outputs = model(inputs)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
total_loss += loss.item()
progress_bar.set_postfix(
{'training_loss': f'{total_loss/len(train_loader):.4f}'}
)

avg_train_loss = total_loss / len(train_loader)
train_losses.append(avg_train_loss)

model.eval()
val_loss = 0
with torch.no_grad():
for inputs, targets in val_loader:
inputs, targets = inputs.to(device), targets.to(device)
outputs = model(inputs)
loss = criterion(outputs, targets)
val_loss += loss.item()

avg_val_loss = val_loss / len(val_loader)
val_losses.append(avg_val_loss)

print(
f"Эпоха {epoch+1}/{epochs}, Потеря на обучении: {avg_train_loss:.4f}, Потеря на валидации: {avg_val_loss:.4f}"
)

scheduler.step()

if avg_val_loss < best_val_loss:
best_val_loss = avg_val_loss
best_model = model.state_dict()

model.load_state_dict(best_model)
return model, train_losses, val_losses


def generate_music(model, seed, length=1000, temperature=1.0):
model.eval()
generated = seed.unsqueeze(0).to(device)
with torch.no_grad():
for _ in tqdm(range(length), desc="Генерация"):
input_seq = generated[:, -seed.size(0):, :]
output = model(input_seq)
next_feature = output[:, -1, :] / temperature
generated = torch.cat(
[generated, next_feature.unsqueeze(1)], dim=1)
return generated.squeeze(0).cpu()


def save_audio(waveform, sample_rate, file_path):
torchaudio.save(file_path, waveform, sample_rate)


def save_model(model, path):
torch.save(model.state_dict(), path)


def load_model(model, path):
state_dict = torch.load(path, map_location=device)
model.load_state_dict(state_dict)
return model


def harmonic_analysis(waveform, sample_rate):
y = librosa.util.normalize(waveform.numpy())
chroma = librosa.feature.chroma_cqt(y=y, sr=sample_rate)
return chroma


def rhythm_analysis(waveform, sample_rate):
y = librosa.util.normalize(waveform.numpy())
onset_env = librosa.onset.onset_strength(y=y, sr=sample_rate)
tempo, beats = librosa.beat.beat_track(
onset_envelope=onset_env, sr=sample_rate
)
return tempo, beats


def style_transfer(content_waveform, style_waveform, sample_rate):
y_content = content_waveform.numpy()
y_style = style_waveform.numpy()

content_spec = np.abs(librosa.stft(y_content))
style_spec = np.abs(librosa.stft(y_style))

n_components = 4
content_nmf = NMF(n_components=n_components, random_state=0)
style_nmf = NMF(n_components=n_components, random_state=0)

content_W = content_nmf.fit_transform(content_spec)
content_H = content_nmf.components_

style_W = style_nmf.fit_transform(style_spec)
style_H = style_nmf.components_

transferred_spec = np.dot(content_W, style_H)
transferred_audio = librosa.istft(transferred_spec)

return torch.FloatTensor(transferred_audio)


class MusicGeneratorApp:
def __init__(self, master):
self.master = master
self.master.title("AI Music Generator")
self.master.geometry("800x600")

self.model = None
self.sample_rate = 22050 # Частота дискретизации по умолчанию
self.train_thread = None
self.train_losses = []
self.val_losses = []

self.create_widgets()

def create_widgets(self):
self.notebook = ttk.Notebook(self.master)
self.notebook.pack(fill=tk.BOTH, expand=True)

self.train_tab = ttk.Frame(self.notebook)
self.generate_tab = ttk.Frame(self.notebook)
self.analysis_tab = ttk.Frame(self.notebook)
self.style_transfer_tab = ttk.Frame(self.notebook)

self.notebook.add(self.train_tab, text="Обучение модели")
self.notebook.add(self.generate_tab, text="Генерация музыки")
self.notebook.add(self.analysis_tab, text="Анализ музыки")
self.notebook.add(self.style_transfer_tab, text="Перенос стиля")

self.create_train_widgets()
self.create_generate_widgets()
self.create_analysis_widgets()
self.create_style_transfer_widgets()

def create_train_widgets(self):
self.train_button = tk.Button(
self.train_tab, text="Обучить модель", command=self.train_model
)
self.train_button.pack(pady=10)

self.load_button = tk.Button(
self.train_tab, text="Загрузить модель", command=self.load_model
)
self.load_button.pack(pady=10)

self.status_label = tk.Label(self.train_tab, text="")
self.status_label.pack(pady=10)

self.progress_bar = ttk.Progressbar(
self.train_tab, orient=tk.HORIZONTAL, length=300, mode='indeterminate'
)
self.progress_bar.pack(pady=10)

self.fig, self.ax = plt.subplots(figsize=(6, 4))
self.canvas = FigureCanvasTkAgg(self.fig, master=self.train_tab)
self.canvas.draw()
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

def create_generate_widgets(self):
self.generate_button = tk.Button(
self.generate_tab, text="Сгенерировать музыку", command=self.generate_music
)
self.generate_button.pack(pady=10)

self.temperature_label = tk.Label(
self.generate_tab, text="Температура:"
)
self.temperature_label.pack()
self.temperature_slider = tk.Scale(
self.generate_tab, from_=0.1, to=2.0, resolution=0.1, orient=tk.HORIZONTAL
)
self.temperature_slider.set(1.0)
self.temperature_slider.pack()

self.length_label = tk.Label(
self.generate_tab, text="Длина (секунды):"
)
self.length_label.pack()
self.length_entry = tk.Entry(self.generate_tab)
self.length_entry.insert(0, "10")
self.length_entry.pack()

self.status_label_generate = tk.Label(self.generate_tab, text="")
self.status_label_generate.pack(pady=10)

self.progress_bar_generate = ttk.Progressbar(
self.generate_tab, orient=tk.HORIZONTAL, length=300, mode='indeterminate'
)
self.progress_bar_generate.pack(pady=10)

def create_analysis_widgets(self):
self.analyze_button = tk.Button(
self.analysis_tab, text="Анализировать музыку", command=self.analyze_music
)
self.analyze_button.pack(pady=10)

self.analysis_text = tk.Text(self.analysis_tab, height=20, width=60)
self.analysis_text.pack(pady=10)

def create_style_transfer_widgets(self):
self.content_button = tk.Button(
self.style_transfer_tab, text="Выбрать контент-аудио", command=self.select_content_audio
)
self.content_button.pack(pady=10)

self.style_button = tk.Button(
self.style_transfer_tab, text="Выбрать стиль-аудио", command=self.select_style_audio
)
self.style_button.pack(pady=10)

self.transfer_button = tk.Button(
self.style_transfer_tab, text="Перенести стиль", command=self.transfer_style
)
self.transfer_button.pack(pady=10)

self.status_label_transfer = tk.Label(self.style_transfer_tab, text="")
self.status_label_transfer.pack(pady=10)

self.progress_bar_transfer = ttk.Progressbar(
self.style_transfer_tab, orient=tk.HORIZONTAL, length=300, mode='indeterminate'
)
self.progress_bar_transfer.pack(pady=10)

def train_model(self):
folder_path = filedialog.askdirectory(
title="Выберите папку с WAV файлами"
)
if not folder_path:
return

self.status_label.config(text="Загрузка и обработка данных...")
self.master.update()

file_paths = [
os.path.join(folder_path, fname)
for fname in os.listdir(folder_path)
if fname.endswith('.wav')
]

if not file_paths:
self.status_label.config(
text="Не найдено WAV файлов в выбранной папке."
)
return

dataset = MusicDataset(file_paths)
self.sample_rate = dataset.target_sample_rate

# Разделение на обучающую и валидационную выборки
train_size = int(0.8 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = torch.utils.data.random_split(
dataset, [train_size, val_size]
)

train_loader = DataLoader(
train_dataset, batch_size=1, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=1)

input_size = dataset[0][0].size(1)
output_size = input_size

d_model = 512
nhead = 8
num_layers = 6

self.model = ImprovedTransformerModel(
input_size, output_size, d_model, nhead, num_layers
)
self.model.to(device)

self.status_label.config(text="Обучение модели...")
self.master.update()

def train_thread():
try:
self.model, self.train_losses, self.val_losses = train_model(
self.model, train_loader, val_loader
)
self.master.after(0, self.update_plot)
self.status_label.config("Модель успешно обучена!")

save_path = filedialog.asksaveasfilename(
defaultextension=".pth", filetypes=[("PyTorch model", "*.pth")]
)
if save_path:
save_model(self.model, save_path)
self.status_label.config(
text="Модель успешно обучена и сохранена!"
)
except Exception as e:
self.status_label.config(
text=f"Ошибка при обучении: {str(e)}"
)
print(f"Ошибка при обучении: {str(e)}")
finally:
self.progress_bar.stop()

self.train_thread = threading.Thread(target=train_thread)
self.train_thread.start()

self.progress_bar.start()

def update_plot(self):
self.ax.clear()
self.ax.plot(self.train_losses, label='Потеря на обучении')
self.ax.plot(self.val_losses, label='Потеря на валидации')
self.ax.set_xlabel('Эпоха')
self.ax.set_ylabel('Потеря')
self.ax.legend()
self.canvas.draw()

def load_model(self):
load_path = filedialog.askopenfilename(
filetypes=[("PyTorch model", "*.pth")]
)
if load_path:
try:
state_dict = torch.load(load_path, map_location=device)
input_size = state_dict['embedding.weight'].size(1)
output_size = state_dict['decoder.weight'].size(0)
d_model = state_dict['embedding.weight'].size(0)
nhead = 8
num_layers = len([
key for key in state_dict.keys()
if key.startswith('transformer_encoder.layers')
])

self.model = ImprovedTransformerModel(
input_size, output_size, d_model, nhead, num_layers
)
self.model = load_model(self.model, load_path)
self.model.to(device)
self.status_label.config(text="Модель успешно загружена!")
except Exception as e:
messagebox.showerror(
"Ошибка", f"Не удалось загрузить модель: {str(e)}"
)

def generate_music(self):
if self.model is None:
messagebox.showwarning(
"Предупреждение", "Пожалуйста, обучите или загрузите модель."
)
return

self.status_label_generate.config(text="Генерация музыки...")
self.master.update()

temperature = self.temperature_slider.get()
try:
length_seconds = float(self.length_entry.get())
except ValueError:
messagebox.showerror(
"Ошибка", "Неверное значение длины. Пожалуйста, введите число."
)
return

length = int(length_seconds * (self.sample_rate / 512)) # Примерная оценка

seed = torch.randn(1, 10, self.model.embedding.in_features)

self.progress_bar_generate.start()

def generate_thread():
try:
generated = generate_music(
self.model, seed, length, temperature
)

save_path = filedialog.asksaveasfilename(
defaultextension=".wav", filetypes=[("WAV files", "*.wav")]
)
if not save_path:
return

generated_features = generated.numpy()

# Восстановление аудио из признаков
try:
reconstructed_audio = librosa.feature.inverse.mfcc_to_audio(
generated_features[:, :20].T
)
reconstructed_audio = torch.FloatTensor(
reconstructed_audio).unsqueeze(0)
reconstructed_audio = reconstructed_audio / torch.max(
torch.abs(reconstructed_audio)
)
save_audio(reconstructed_audio,
self.sample_rate, save_path)
self.status_label_generate.config(
text="Музыка успешно сгенерирована и сохранена!"
)
except Exception as e:
messagebox.showerror(
"Ошибка", f"Не удалось восстановить аудио: {str(e)}"
)
except Exception as e:
messagebox.showerror(
"Ошибка", f"Не удалось сгенерировать или сохранить аудио: {str(e)}"
)
finally:
self.progress_bar_generate.stop()

threading.Thread(target=generate_thread).start()

def analyze_music(self):
file_path = filedialog.askopenfilename(
filetypes=[("WAV files", "*.wav")]
)
if not file_path:
return

waveform, sample_rate = load_audio(file_path)

chroma = harmonic_analysis(waveform, sample_rate)
tempo, beats = rhythm_analysis(waveform, sample_rate)

analysis_text = f"Темп: {tempo} BPM\n\n"
analysis_text += "Хрома-признаки:\n"
for i, chr in enumerate(chroma.T):
if i % 4 == 0:
analysis_text += "\n"
analysis_text += f"{chr.max():.2f} "

self.analysis_text.delete('1.0', tk.END)
self.analysis_text.insert(tk.END, analysis_text)

def select_content_audio(self):
self.content_path = filedialog.askopenfilename(
filetypes=[("WAV files", "*.wav")]
)
if self.content_path:
self.status_label_transfer.config(text="Контент-аудио выбрано")

def select_style_audio(self):
self.style_path = filedialog.askopenfilename(
filetypes=[("WAV files", "*.wav")]
)
if self.style_path:
self.status_label_transfer.config(text="Стиль-аудио выбрано")

def transfer_style(self):
if not hasattr(self, 'content_path') or not hasattr(self, 'style_path'):
messagebox.showwarning(
"Предупреждение", "Пожалуйста, выберите контент и стиль аудио."
)
return

self.progress_bar_transfer.start()

def transfer_thread():
try:
content_waveform, content_sample_rate = load_audio(
self.content_path
)
style_waveform, style_sample_rate = load_audio(
self.style_path
)

if content_sample_rate != style_sample_rate:
style_waveform = torchaudio.functional.resample(
style_waveform, style_sample_rate, content_sample_rate
)

transferred_audio = style_transfer(
content_waveform, style_waveform, content_sample_rate
)

save_path = filedialog.asksaveasfilename(
defaultextension=".wav", filetypes=[("WAV files", "*.wav")]
)
if not save_path:
return

save_audio(transferred_audio.unsqueeze(0),
content_sample_rate, save_path)
self.status_label_transfer.config(
text="Перенос стиля выполнен и сохранен!"
)
except Exception as e:
messagebox.showerror(
"Ошибка", f"Не удалось выполнить перенос стиля: {str(e)}"
)
finally:
self.progress_bar_transfer.stop()

threading.Thread(target=transfer_thread).start()


def main():
root = tk.Tk()
app = MusicGeneratorApp(root)
root.mainloop()


if __name__ == "__main__":
main()