Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import numpy as np | |
| import pandas as pd | |
| from typing import Dict | |
| import time | |
| from sklearn.metrics import accuracy_score, mean_squared_error, classification_report | |
| import torch | |
| import torch.nn as nn | |
| import matplotlib.pyplot as plt | |
| # Additional ML helper functions | |
| def evaluate_ml_solution(y_true, y_pred, task_type='classification'): | |
| """Evaluate ML model predictions""" | |
| if task_type == 'classification': | |
| accuracy = accuracy_score(y_true, y_pred) | |
| report = classification_report(y_true, y_pred) | |
| return f"Accuracy: {accuracy:.4f}\n\nDetailed Report:\n{report}" | |
| else: | |
| mse = mean_squared_error(y_true, y_pred) | |
| rmse = np.sqrt(mse) | |
| return f"MSE: {mse:.4f}\nRMSE: {rmse:.4f}" | |
| # Extended problem set including ML problems | |
| PROBLEM_DATA = { | |
| # Original Algorithm Problems | |
| "Valid Parentheses": { | |
| "type": "algorithm", | |
| "difficulty": "easy", | |
| "description": "Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.", | |
| "test_cases": [ | |
| {'input': "()", 'expected': True}, | |
| {'input': "()[]{}", 'expected': True}, | |
| {'input': "(]", 'expected': False} | |
| ], | |
| "sample_input": "()", | |
| "starter_code": """def solution(s: str) -> bool: | |
| # Write your solution here | |
| pass""" | |
| }, | |
| # ML Classification Problem | |
| "Binary Classification": { | |
| "type": "ml_classification", | |
| "difficulty": "medium", | |
| "description": "Create a binary classifier for the provided dataset. Features include numerical values, target is binary (0/1).", | |
| "test_cases": [ | |
| { | |
| 'input': pd.DataFrame({ | |
| 'feature1': [1.2, 2.3, 3.4, 4.5], | |
| 'feature2': [2.1, 3.2, 4.3, 5.4] | |
| }), | |
| 'expected': np.array([0, 1, 1, 0]) | |
| } | |
| ], | |
| "starter_code": """class MLSolution: | |
| def __init__(self): | |
| self.model = None | |
| def fit(self, X, y): | |
| # Implement training logic | |
| pass | |
| def predict(self, X): | |
| # Implement prediction logic | |
| return np.zeros(len(X))""" | |
| }, | |
| # Neural Network Problem | |
| "Simple Neural Network": { | |
| "type": "deep_learning", | |
| "difficulty": "hard", | |
| "description": "Implement a simple neural network for binary classification using PyTorch.", | |
| "test_cases": [ | |
| { | |
| 'input': torch.randn(10, 5), # 10 samples, 5 features | |
| 'expected': torch.randint(0, 2, (10,)) | |
| } | |
| ], | |
| "starter_code": """class NeuralNetwork(nn.Module): | |
| def __init__(self, input_size): | |
| super(NeuralNetwork, self).__init__() | |
| self.layer1 = nn.Linear(input_size, 64) | |
| self.layer2 = nn.Linear(64, 1) | |
| self.sigmoid = nn.Sigmoid() | |
| def forward(self, x): | |
| x = torch.relu(self.layer1(x)) | |
| x = self.sigmoid(self.layer2(x)) | |
| return x""" | |
| }, | |
| # Regression Problem | |
| "House Price Prediction": { | |
| "type": "ml_regression", | |
| "difficulty": "medium", | |
| "description": "Implement a regression model to predict house prices based on features like size, location, etc.", | |
| "test_cases": [ | |
| { | |
| 'input': pd.DataFrame({ | |
| 'size': [1500, 2000, 2500], | |
| 'rooms': [3, 4, 5], | |
| 'location_score': [8, 7, 9] | |
| }), | |
| 'expected': np.array([250000, 300000, 400000]) | |
| } | |
| ], | |
| "starter_code": """class RegressionSolution: | |
| def __init__(self): | |
| self.model = None | |
| def fit(self, X, y): | |
| # Implement training logic | |
| pass | |
| def predict(self, X): | |
| # Implement prediction logic | |
| return np.zeros(len(X))""" | |
| } | |
| } | |
| def create_sample_data(problem_type: str) -> Dict: | |
| """Create sample datasets for ML problems""" | |
| if problem_type == 'ml_classification': | |
| X_train = pd.DataFrame(np.random.randn(100, 2), columns=['feature1', 'feature2']) | |
| y_train = np.random.randint(0, 2, 100) | |
| X_test = pd.DataFrame(np.random.randn(20, 2), columns=['feature1', 'feature2']) | |
| y_test = np.random.randint(0, 2, 20) | |
| return {'X_train': X_train, 'y_train': y_train, 'X_test': X_test, 'y_test': y_test} | |
| elif problem_type == 'ml_regression': | |
| X_train = pd.DataFrame(np.random.randn(100, 3), | |
| columns=['size', 'rooms', 'location_score']) | |
| y_train = np.random.uniform(200000, 500000, 100) | |
| X_test = pd.DataFrame(np.random.randn(20, 3), | |
| columns=['size', 'rooms', 'location_score']) | |
| y_test = np.random.uniform(200000, 500000, 20) | |
| return {'X_train': X_train, 'y_train': y_train, 'X_test': X_test, 'y_test': y_test} | |
| elif problem_type == 'deep_learning': | |
| # Generate sample data for neural network | |
| X_train = torch.randn(100, 5) # 100 samples, 5 features | |
| y_train = torch.randint(0, 2, (100,)) # Binary classification | |
| X_test = torch.randn(20, 5) # 20 samples, 5 features | |
| y_test = torch.randint(0, 2, (20,)) # Binary classification | |
| return {'X_train': X_train, 'y_train': y_train, 'X_test': X_test, 'y_test': y_test} | |
| return None | |
| def run_tests(problem_name: str, user_code: str) -> str: | |
| try: | |
| problem = PROBLEM_DATA[problem_name] | |
| if problem["type"] == "algorithm": | |
| # Execute algorithm problems | |
| namespace = {} | |
| exec(user_code, namespace) | |
| results = [] | |
| for i, test in enumerate(problem["test_cases"], 1): | |
| try: | |
| start_time = time.time() | |
| output = namespace["solution"](test["input"]) | |
| execution_time = time.time() - start_time | |
| passed = output == test["expected"] | |
| results.append( | |
| f"Test #{i}:\n" | |
| f"Input: {test['input']}\n" | |
| f"Expected: {test['expected']}\n" | |
| f"Got: {output}\n" | |
| f"Time: {execution_time:.6f}s\n" | |
| f"Status: {'✓ PASSED' if passed else '✗ FAILED'}\n" | |
| ) | |
| except Exception as e: | |
| results.append(f"Test #{i} Error: {str(e)}\n") | |
| return "\n".join(results) | |
| else: | |
| # Execute ML problems | |
| namespace = {"np": np, "pd": pd, "nn": nn, "torch": torch} | |
| exec(user_code, namespace) | |
| # Create sample data | |
| data = create_sample_data(problem["type"]) | |
| if not data: | |
| return "Error: Invalid problem type" | |
| try: | |
| if problem["type"] in ["ml_classification", "ml_regression"]: | |
| # Initialize and train model | |
| model = namespace["MLSolution"]() | |
| model.fit(data["X_train"], data["y_train"]) | |
| # Make predictions | |
| predictions = model.predict(data["X_test"]) | |
| # Evaluate | |
| eval_result = evaluate_ml_solution( | |
| data["y_test"], | |
| predictions, | |
| "classification" if problem["type"] == "ml_classification" else "regression" | |
| ) | |
| return f"Model Evaluation:\n{eval_result}" | |
| elif problem["type"] == "deep_learning": | |
| # Initialize neural network | |
| model = namespace["NeuralNetwork"](data["X_train"].shape[1]) | |
| criterion = nn.BCELoss() # Binary cross-entropy loss | |
| optimizer = torch.optim.Adam(model.parameters(), lr=0.01) | |
| # Convert data to tensors | |
| X_train = data["X_train"].float() | |
| y_train = data["y_train"].float().view(-1, 1) | |
| X_test = data["X_test"].float() | |
| y_test = data["y_test"].float().view(-1, 1) | |
| # Train the model | |
| for epoch in range(10): # 10 epochs | |
| optimizer.zero_grad() | |
| outputs = model(X_train) | |
| loss = criterion(outputs, y_train) | |
| loss.backward() | |
| optimizer.step() | |
| # Evaluate the model | |
| with torch.no_grad(): | |
| predictions = model(X_test) | |
| predictions = (predictions > 0.5).float() # Convert probabilities to binary predictions | |
| accuracy = (predictions == y_test).float().mean() | |
| return f"Neural Network Evaluation:\nAccuracy: {accuracy.item():.4f}" | |
| except Exception as e: | |
| return f"Error in ML execution: {str(e)}" | |
| except Exception as e: | |
| return f"Error in code execution: {str(e)}" | |
| # Create Gradio interface with enhanced features | |
| def create_interface(): | |
| with gr.Blocks(title="Advanced LeetCode & ML Testing Platform") as iface: | |
| # All components and event handlers must be defined within this 'with' block | |
| gr.Markdown("# Advanced LeetCode & ML Testing Platform") | |
| with gr.Tabs(): | |
| with gr.Tab("Problem Solving"): | |
| problem_dropdown = gr.Dropdown( | |
| choices=list(PROBLEM_DATA.keys()), | |
| label="Select Problem" | |
| ) | |
| difficulty_display = gr.Textbox(label="Difficulty") | |
| problem_type = gr.Textbox(label="Problem Type") | |
| description_text = gr.Textbox(label="Description", lines=5) | |
| code_input = gr.Textbox(label="Your Code", lines=10, value="") | |
| results_output = gr.Textbox(label="Test Results", value="", lines=10) | |
| with gr.Row(): | |
| run_button = gr.Button("Run Tests") | |
| clear_button = gr.Button("Clear Code") | |
| # Event handler for Run Tests button (inside Blocks context) | |
| run_button.click( | |
| run_tests, | |
| inputs=[problem_dropdown, code_input], | |
| outputs=[results_output] | |
| ) | |
| # Event handler for Clear Code button (inside Blocks context) | |
| clear_button.click( | |
| lambda: "", | |
| inputs=[], | |
| outputs=[code_input] | |
| ) | |
| # Event handler for problem selection (inside Blocks context) | |
| def update_problem_info(problem_name): | |
| problem = PROBLEM_DATA[problem_name] | |
| return ( | |
| problem["difficulty"], | |
| problem["type"], | |
| problem["description"], | |
| problem["starter_code"], | |
| "" # Clear results | |
| ) | |
| problem_dropdown.change( | |
| update_problem_info, | |
| inputs=[problem_dropdown], | |
| outputs=[ | |
| difficulty_display, | |
| problem_type, | |
| description_text, | |
| code_input, | |
| results_output | |
| ] | |
| ) | |
| with gr.Tab("Visualization"): | |
| with gr.Row(): | |
| plot_type = gr.Dropdown( | |
| choices=["Learning Curve", "Confusion Matrix", "Feature Importance"], | |
| label="Select Plot Type" | |
| ) | |
| visualize_button = gr.Button("Generate Visualization") | |
| plot_output = gr.Plot(label="Visualization") | |
| # Event handler for visualization | |
| def generate_visualization(plot_type): | |
| if plot_type == "Learning Curve": | |
| # Example learning curve | |
| plt.figure() | |
| plt.plot([0, 1, 2, 3, 4], [0.8, 0.7, 0.6, 0.5, 0.4], label="Training Loss") | |
| plt.plot([0, 1, 2, 3, 4], [0.9, 0.8, 0.7, 0.6, 0.5], label="Validation Loss") | |
| plt.xlabel("Epochs") | |
| plt.ylabel("Loss") | |
| plt.title("Learning Curve") | |
| plt.legend() | |
| return plt | |
| else: | |
| return None | |
| visualize_button.click( | |
| generate_visualization, | |
| inputs=[plot_type], | |
| outputs=[plot_output] | |
| ) | |
| return iface | |
| if __name__ == "__main__": | |
| iface = create_interface() | |
| iface.launch() |