code: def _create_input_model(self, x_train, y_train, x_val, y_val, params):
      import wrangle as wr
  
      from tensorflow.keras.models import Sequential
      from tensorflow.keras.layers import Dropout, Flatten
      from tensorflow.keras.layers import (
          LSTM,
          Conv1D,
          SimpleRNN,
          Dense,
          Bidirectional,
      )
  
      model = Sequential()
  
      if params["network"] != "dense":
          x_train = wr.array_reshape_conv1d(x_train)
          x_val = wr.array_reshape_conv1d(x_val)
  
      if params["network"] == "conv1d":
          model.add(Conv1D(params["first_neuron"], x_train.shape[1]))
          model.add(Flatten())
  
      elif params["network"] == "lstm":
          model.add(LSTM(params["first_neuron"]))
  
      if params["network"] == "bidirectional_lstm":
          model.add(Bidirectional(LSTM(params["first_neuron"])))
  
      elif params["network"] == "simplernn":
          model.add(SimpleRNN(params["first_neuron"]))
  
      elif params["network"] == "dense":
          model.add(
              Dense(
                  params["first_neuron"],
                  input_dim=x_train.shape[1],
                  activation="relu",
                  kernel_initializer=params["kernel_initializer"],
              )
          )
  
      model.add(Dropout(params["dropout"]))
  
      # add hidden layers to the model
      from talos.model.hidden_layers import hidden_layers
  
      hidden_layers(model, params, 1)
  
      # get the right activation and last_neuron based on task
      from talos.model.output_layer import output_layer
  
      activation, last_neuron = output_layer(
          self.task, params["last_activation"], y_train, y_val
      )
  
      model.add(
          Dense(
              last_neuron,
              activation=activation,
              kernel_initializer=params["kernel_initializer"],
          )
      )
  
      # bundle the optimizer with learning rate changes
      from talos.model.normalizers import lr_normalizer
  
      optimizer = params["optimizer"](
          lr=lr_normalizer(params["lr"], params["optimizer"])
      )
  
      # compile the model
      model.compile(
          optimizer=optimizer,
          loss=params["losses"],
          metrics=self.metrics,
      )
  
      # fit the model
      out = model.fit(
          x_train,
          y_train,
          batch_size=params["batch_size"],
          epochs=params["epochs"],
          verbose=0,
          callbacks=[self.callback(self.experiment_name, params)],
          validation_data=(x_val, y_val),
      )
  
      # pass the output to Talos
      return out, model
  
label_desc: Use image node_id 3 for calling the AutoModel obj's underlying member method code with example usage: obj._create_input_model(x_train, y_train, x_val, y_val, params) and returns: out,  model