OpenCV python sklearn implementation of randomized hyperparameter search

"""
House price prediction dataset Performing hyperparametric searches with sklearn
"""
import matplotlib as mpl
import  as plt
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import tensorflow as tf
from tensorflow_core.._v2 import keras # Can't use python
from  import StandardScaler
from  import fetch_california_housing
from sklearn.model_selection import train_test_split, RandomizedSearchCV
from  import reciprocal

['TF_CPP_MIN_LOG_LEVEL'] = '2'
assert tf.__version__.startswith('2.')

# 0. Print the version of the imported module
print(tf.__version__)
print(sys.version_info)
for module in mpl, np, sklearn, pd, tf, keras:
  print("%s version:%s" % (module.__name__, module.__version__))


# Show learning curve
def plot_learning_curves(his):
  ().plot(figsize=(8, 5))
  (True)
  ().set_ylim(0, 1)
  ()


# 1. load dataset california house prices
housing = fetch_california_housing()

print()
print()
print()

# 2. Split dataset Training set Validation set Test set
x_train_all, x_test, y_train_all, y_test = train_test_split(
  , , random_state=7)
x_train, x_valid, y_train, y_valid = train_test_split(
  x_train_all, y_train_all, random_state=11)

print(x_train.shape, y_train.shape)
print(x_valid.shape, y_valid.shape)
print(x_test.shape, y_test.shape)

# 3. Data set normalization
scaler = StandardScaler()
x_train_scaled = scaler.fit_transform(x_train)
x_valid_scaled = scaler.fit_transform(x_valid)
x_test_scaled = scaler.fit_transform(x_test)


# Create keras models
def build_model(hidden_layers=1, # Parameters of the middle tier
        layer_size=30,
        learning_rate=3e-3):
  # Create the network layer
  model = ()
  ((layer_size, activation="relu",
                 input_shape=x_train.shape[1:]))
 # Hidden Layer Settings
  for _ in range(hidden_layers - 1):
    ((layer_size,
                   activation="relu"))
  ((1))

  # Optimizer learning rate
  optimizer = (lr=learning_rate)
  (loss="mse", optimizer=optimizer)

  return model


def main():
  # RandomizedSearchCV

  # 1. Models converted to sklearn
  sk_learn_model = .scikit_learn.KerasRegressor(build_model)

  callbacks = [(patience=5, min_delta=1e-2)]

  history = sk_learn_model.fit(x_train_scaled, y_train, epochs=100,
                 validation_data=(x_valid_scaled, y_valid),
                 callbacks=callbacks)
  # 2. Define the set of hyperparameters
  # f(x) = 1/(x*log(b/a)) a <= x <= b
  param_distribution = {
    "hidden_layers": [1, 2, 3, 4],
    "layer_size": (1, 100),
    "learning_rate": reciprocal(1e-4, 1e-2),
  }

  # 3. Execute hypersearch parameters
  # cross_validation: training set divided into n parts, n-1 training, last validation.
  random_search_cv = RandomizedSearchCV(sk_learn_model, param_distribution,
                     n_iter=10,
                     cv=3,
                     n_jobs=1)
  random_search_cv.fit(x_train_scaled, y_train, epochs=100,
             validation_data=(x_valid_scaled, y_valid),
             callbacks=callbacks)
  # 4. Display hyperparameters
  print(random_search_cv.best_params_)
  print(random_search_cv.best_score_)
  print(random_search_cv.best_estimator_)

  model = random_search_cv.best_estimator_.model
  print((x_test_scaled, y_test))

  # 5. Print the model training process
  plot_learning_curves(history)


if __name__ == '__main__':
  main()