|
--- |
|
license: other |
|
license_name: joke |
|
license_link: LICENSE |
|
datasets: |
|
- ConquestAce/spotify-songs |
|
pipeline_tag: audio-classification |
|
tags: |
|
- music |
|
--- |
|
|
|
This model is extremely weak. I am not good at data science |
|
|
|
# Iterations |
|
**null**: |
|
|
|
<details> |
|
<summary><b>Trained on 500 Epoch with 2.1 million song data from Spotify Database</b></summary> |
|
|
|
``` |
|
import torch |
|
import torch.nn as nn |
|
import torch.optim as optim |
|
from sklearn.model_selection import train_test_split |
|
from sklearn.preprocessing import StandardScaler |
|
import pandas as pd |
|
|
|
|
|
# Split the data into features and target variable |
|
X = df[numerical_features[:-1]].values # all except popularity |
|
y = df['popularity'].values |
|
|
|
# Split into training and testing sets |
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) |
|
|
|
# Standardize the features |
|
scaler = StandardScaler() |
|
X_train = scaler.fit_transform(X_train) |
|
X_test = scaler.transform(X_test) |
|
|
|
# Convert to PyTorch tensors |
|
X_train_tensor = torch.FloatTensor(X_train) |
|
y_train_tensor = torch.FloatTensor(y_train).view(-1, 1) # shape to (N, 1) |
|
X_test_tensor = torch.FloatTensor(X_test) |
|
y_test_tensor = torch.FloatTensor(y_test).view(-1, 1) |
|
|
|
# Define the neural network model |
|
class PopularityPredictor(nn.Module): |
|
def __init__(self): |
|
super(PopularityPredictor, self).__init__() |
|
self.fc1 = nn.Linear(X_train.shape[1], 128) |
|
self.fc2 = nn.Linear(128, 64) |
|
self.fc3 = nn.Linear(64, 32) |
|
self.fc4 = nn.Linear(32, 1) |
|
|
|
def forward(self, x): |
|
x = torch.relu(self.fc1(x)) |
|
x = torch.relu(self.fc2(x)) |
|
x = self.fc3(x) |
|
return x |
|
|
|
# Create an instance of the model |
|
model = PopularityPredictor() |
|
|
|
# Define the loss function and optimizer |
|
criterion = nn.MSELoss() |
|
optimizer = optim.Adam(model.parameters(), lr=0.001) |
|
|
|
# Train the model |
|
num_epochs = 100 |
|
for epoch in range(num_epochs): |
|
model.train() |
|
optimizer.zero_grad() |
|
|
|
# Forward pass |
|
outputs = model(X_train_tensor) |
|
loss = criterion(outputs, y_train_tensor) |
|
|
|
# Backward pass and optimization |
|
loss.backward() |
|
optimizer.step() |
|
|
|
if (epoch+1) % 10 == 0: |
|
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}') |
|
|
|
# Evaluate the model |
|
model.eval() |
|
with torch.no_grad(): |
|
predicted = model(X_test_tensor) |
|
|
|
``` |
|
|
|
</details> |
