input: Write a python function to train a neural network classifier using evolutionary optimization and return its accuracy score. 
  assert round(train_nn_classifier(), 2) >= 0.5
output: def train_nn_classifier():
      import numpy as np
      from sklearn.datasets import make_classification
      from sklearn.model_selection import train_test_split
      from sklearn.neural_network import MLPClassifier
      from sklearn.metrics import accuracy_score
      from scipy.optimize import differential_evolution
  
      # Generate a synthetic classification dataset
      X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
  
      # Define the objective function for optimization
      def objective_function(params):
          hidden_layer_sizes = tuple(int(params[i]) for i in range(len(params)))
          clf = MLPClassifier(hidden_layer_sizes=hidden_layer_sizes, max_iter=2000, random_state=42)
          clf.fit(X_train, y_train)
          y_pred = clf.predict(X_test)
          accuracy = accuracy_score(y_test, y_pred)
          return -accuracy  # Minimize negative accuracy
  
      # Define the bounds for each parameter (number of neurons in each hidden layer)
      bounds = [(5, 100), (5, 100), (5, 100)]  # Example for up to 3 hidden layers
  
      # Perform differential evolution optimization
      result = differential_evolution(objective_function, bounds, strategy='best1bin', maxiter=100, popsize=15, tol=0.01, mutation=(0.5, 1), recombination=0.7, seed=42)
  
      # Get the best parameters
      best_params = result.x
      best_hidden_layer_sizes = tuple(int(param) for param in best_params)
  
      # Train the final model with the best parameters
      final_clf = MLPClassifier(hidden_layer_sizes=best_hidden_layer_sizes, max_iter=2000, random_state=42)
      final_clf.fit(X_train, y_train)
      y_pred_final = final_clf.predict(X_test)
      final_accuracy = accuracy_score(y_test, y_pred_final)
  
      return final_accuracy