Update README.md

README.md

@@ -1,5 +1,3 @@
-This model is extremely weak. I am not good at data science
-
 ---
 license: other
 license_name: joke
@@ -9,4 +7,84 @@ datasets:
 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>
+```python
+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>