def createDNNModel(input_dim, end_act, loss, outnodes=1): config = DNNConfig() neurons = config.getNeurons() init_wt = config.getWeightInit() dropouts = config.getDropoutRate() regs = config.getRegularizer() act = config.getActivation() optm_algo = config.getAlgorithm() lr = config.getLearnRate() mom = config.getMomentum() model = Sequential() # add two layers to standardize model.add(Dense(input_dim,input_dim=input_dim,name='offset', trainable=False, kernel_initializer = initializers.Identity(gain=1.))) model.add(Dense(input_dim,input_dim=input_dim,name='scaler', trainable=False, kernel_initializer = initializers.Identity(gain=1.))) for n in range(len(neurons)): reg,rv=regs[n].split(":") regler = Regularizer_switcher[reg] if n == 0: model.add(Dense(neurons[n], input_dim = input_dim, kernel_initializer=init_wt, kernel_regularizer=regler(float(rv)) )) else: model.add(Dense(neurons[n], kernel_initializer=init_wt, kernel_regularizer=regler(float(rv)) )) model.add(BatchNormalization(axis=1)) model.add(Activation(act[n])) if dropouts[n] > 0.0: model.add(Dropout(dropouts[n])) if lr < 0: optm = Optimizer_switcher[optm_algo]() else: if optm_algo == "SGD": optm = Optimizer_switcher[optm_algo](lr=lr,momentum=mom) else: optm = Optimizer_switcher[optm_algo](lr=lr) model.add(Dense(outnodes, kernel_initializer=init_wt, activation = end_act,name='output')) model.compile(loss = loss, optimizer = optm, metrics=['accuracy']) model.summary() return model
def add_rnn(device): with tf.device(device): input = layers.Input(batch_shape=(args.batch_size, args.length), dtype="uint8") log.info("Added %s", input) embedding = layers.Embedding( 256, 256, embeddings_initializer=initializers.Identity(), trainable=False)(input) log.info("Added %s", embedding) layer = embedding layer_sizes = [int(n) for n in args.layers.split(",")] for i, nn in enumerate(layer_sizes): with tf.device(device): layer_type = getattr(layers, args.type) ret_seqs = (i < len(layer_sizes) - 1) try: layer = layer_type(nn, return_sequences=ret_seqs, implementation=2)(layer) except TypeError: # implementation kwarg is not present in CuDNN layers layer = layer_type(nn, return_sequences=ret_seqs)(layer) log.info("Added %s", layer) if args.dropout > 0: layer = layers.Dropout(args.dropout)(layer) log.info("Added %s", layer) return input, layer
def get_tower_model(img_shape): model = Sequential() model.add(SimpleRNN(hidden_units, kernel_initializer=initializers.RandomUniform(minval=-.1,maxval=.1), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', batch_input_shape=(None, img_shape[0], img_shape[1]))) model.add(Dense(num_classes)) return model
def create_sequential_model(size): model = Sequential() model.add( SimpleRNN(100, kernel_initializer=initializers.RandomNormal(stddev=0.01), recurrent_initializer=initializers.Identity(gain=0.5), activation='relu', input_shape=size)) model.add(Dense(classes)) model.add(Activation('softmax')) return model
def getInitializer(init_name, learning_rate, opt, functions): if init_name == "rnormal": init = initializers.RandomNormal() elif init_name == "runiform": init = initializers.RandomUniform() elif init_name == "varscaling": init = initializers.VarianceScaling() elif init_name == "orth": init = initializers.Orthogonal() elif init_name == "id": init = initializers.Identity() elif init_name == "lecun_uniform": init = initializers.lecun_uniform() elif init_name == "glorot_normal": init = initializers.glorot_normal() elif init_name == "glorot_uniform": init = initializers.glorot_uniform() elif init_name == "he_normal": init = initializers.he_normal() elif init_name == "he_uniform": init = initializers.he_uniform() if opt == "Adam": optimizer = optimizers.Adam(lr=learning_rate) elif opt == "Adagrad": optimizer = optimizers.Adagrad(lr=learning_rate) elif opt == "Adadelta": optimizer = optimizers.Adadelta(lr=learning_rate) elif opt == "Adamax": optimizer = optimizers.Adamax(lr=learning_rate) elif opt == "Nadam": optimizer = optimizers.Nadam(lr=learning_rate) elif opt == "sgd": optimizer = optimizers.SGD(lr=learning_rate) elif opt == "RMSprop": optimizer = optimizers.RMSprop(lr=learning_rate) if functions.startswith("maxout"): functions, maxout_k = functions.split("-") maxout_k = int(maxout_k) else: maxout_k = 3 if functions.startswith("leakyrelu"): if "-" in functions: functions, maxout_k = functions.split("-") maxout_k = float(maxout_k) else: maxout_k = 0.01 return init, optimizer, functions, maxout_k
def getSimpleRNNModel(self): model = Sequential() model.add(SimpleRNN(11, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation=LeakyReLU(), return_sequences = False, input_shape=(11,1))) model.add(Dense(10, kernel_initializer="uniform", activation=LeakyReLU())) model.add(Dense(1, kernel_initializer="uniform", activation='linear')) #rmsprop = RMSprop(lr=0.001) model.compile(loss='mse', optimizer='adam') model.summary() return model
def init_model(hidden_units, inputs, lr): model = Sequential() model.add( SimpleRNN(hidden_units, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', input_shape=inputs)) model.add(Dense(NUM_CLASSES)) model.add(Activation('softmax')) rmsprop = RMSprop(lr=lr) model.compile(loss='categorical_crossentropy', optimizer=rmsprop, metrics=['accuracy']) return model
def rnn010(num_in,num_out): model = Sequential() # model.add(SimpleRNN(num_in*4, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', input_shape=(num_in,1) )) # model.add(Dense(num_out,activation='softmax')) # rmsprop = RMSprop(lr=1e-6) model.compile(loss='categorical_crossentropy',optimizer=rmsprop,metrics=['accuracy']) # return model
def get_model(x_train, y_train, x_test, y_test): x_train = x_train.reshape(x_train.shape[0], -1, 1) x_test = x_test.reshape(x_test.shape[0], -1, 1) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) print('Evaluate IRNN...') model = Sequential() model.add(SimpleRNN(hidden_units, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', input_shape=x_train.shape[1:])) model.add(Dense(num_classes)) model.add(Activation('softmax')) rmsprop = RMSprop(lr=learning_rate) model.compile(loss='categorical_crossentropy', optimizer=rmsprop, metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) scores = model.evaluate(x_test, y_test, verbose=0) print('IRNN test score:', scores[0]) print('IRNN test accuracy:', scores[1]) return model
def __create_model_rnn(self, learning_rate=0.001, epochs=1, batch_size=32): self.batch_size = batch_size # Size of each batch # self.n_epochs = 200 self.n_epochs = epochs hidden_units = 100 # you should set learning rate to 1e-6 # clip_norm = 1.0 self.model = Sequential() self.model.add( SimpleRNN( hidden_units, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', input_shape=self.x_train.shape[1:])) self.model.add(Dense(self.num_classes)) self.model.add(Activation('softmax')) rmsprop = RMSprop(lr=learning_rate) self.model.compile(loss='categorical_crossentropy', optimizer=rmsprop, metrics=['accuracy']) print(self.model.summary())
def create_base_network(input_dim): '''Base network to be shared (eq. to feature extraction). ''' seq = Sequential() """ seq.add(Dense(128, input_shape=(input_dim,), activation='relu')) seq.add(Dropout(0.1)) seq.add(Dense(128, activation='relu')) seq.add(Dropout(0.1)) seq.add(Dense(128, activation='relu')) """ hidden_units = 100 seq.add( SimpleRNN(hidden_units, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', input_shape=(None, 15, 12))) seq.add(Dense(128, activation='relu')) #""" return seq
for i in range(x_test.shape[2]): x_test[:, i, :] = scalers[i].transform(x_test[:, i, :]) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # convert class vectors to binary class matrices #y_train = keras.utils.to_categorical(y_train, num_classes) #y_test = keras.utils.to_categorical(y_test, num_classes) model = Sequential() model.add( SimpleRNN(hidden_units, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', input_shape=x_train.shape[1:])) model.add(Dense(num_classes)) model.add(Dense(num_classes, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=.00001), metrics=['accuracy']) history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs,
pytest.param( initializers.truncated_normal(mean=0.2, stddev=0.003, seed=42), dict(class_name="truncated_normal", mean=0.2, stddev=0.003, seed=42), id="tn_1", ), pytest.param( initializers.Orthogonal(1.1), dict(class_name="orthogonal", gain=1.1, seed=None), id="o_0", ), pytest.param( initializers.orthogonal(gain=1.2, seed=42), dict(class_name="orthogonal", gain=1.2, seed=42), id="o_1", ), pytest.param(initializers.Identity(1.1), dict(class_name="identity", gain=1.1), id="i_0"), pytest.param(initializers.identity(), dict(class_name="identity", gain=1.0), id="i_1"), #################### VarianceScaling #################### pytest.param( initializers.glorot_normal(), dict(class_name="glorot_normal", seed=None), id="gn_0" ), pytest.param( initializers.glorot_uniform(42), dict(class_name="glorot_uniform", seed=42), id="gu_0" ), pytest.param(initializers.he_normal(), dict(class_name="he_normal", seed=None), id="hn_0"), pytest.param( initializers.he_uniform(42), dict(class_name="he_uniform", seed=42), id="hu_0" ), pytest.param( initializers.lecun_normal(), dict(class_name="lecun_normal", seed=None), id="ln_0" ),
def build(self, dafm_type="dafm-afm", optimizer="rmsprop", learning_rate=0.01, activation="linear", Q_jk_initialize=0, section="", section_count=0, model1="", stateful=False, theta_student="False", student_count=0, binary="False"): skills = np.shape(Q_jk_initialize)[1] steps = np.shape(Q_jk_initialize)[0] self.activation = activation if '-' in self.activation: activation = self.custom_activation if dafm_type.split("_")[-1] == "different": skills = int(float(dafm_type.split("_")[-2]) * skills) dafm_type = dafm_type.split('_')[0] if dafm_type.split("_")[0] == "round-fine-tuned": try: self.round_threshold = float(dafm_type.split("_")[-1]) dafm_type = dafm_type.split("_")[0] except: pass q_jk_size = skills if '^' in dafm_type: q_jk_size = skills skills = int(float(dafm_type.split('^')[-1]) * skills) dafm_type = dafm_type.split('^')[0] self.dafm_type = dafm_type if dafm_type == "random-uniform" or dafm_type == "random-normal": qtrainable, finetuning, randomize = True, False, True self.random_init = dafm_type.split('-')[-1] elif dafm_type == "dafm-afm": qtrainable, finetuning, randomize = False, False, False elif dafm_type == "fine-tuned": qtrainable, finetuning, randomize = True, True, False elif dafm_type == "kcinitialize": qtrainable, finetuning, randomize = True, False, False elif dafm_type == "round-fine-tuned": # if not self.round_threshold == -1: # rounded_Qjk = np.abs(Q_jk1 - Q_jk_initialize) # Q_jk1[rounded_Qjk <= self.round_threshold] = Q_jk_initialize[rounded_Qjk <= self.round_threshold] # Q_jk1[rounded_Qjk > self.round_threshold] = np.ones(np.shape(Q_jk_initialize[rounded_Qjk > self.round_threshold])) - Q_jk_initialize[rounded_Qjk > self.round_threshold] # else: Q_jk1 = model1.get_layer("Q_jk").get_weights()[0] Q_jk1 = np.minimum( np.ones(np.shape(Q_jk1)), np.maximum(np.round(Q_jk1), np.zeros(np.shape(Q_jk1)))) model1.get_layer("Q_jk").set_weights([Q_jk1]) return model1 elif dafm_type == "qjk-dense": qtrainable, finetuning, randomize = False, False, False activation_dense = activation elif dafm_type == "random-qjk-dense-normal" or dafm_type == "random-qjk-dense-uniform": qtrainable, finetuning, randomize = False, False, True self.random_init = dafm_type.split('-')[-1] activation_dense = activation else: print("No Valid Model Found") sys.exit() if section == "onehot": section_input = Input(batch_shape=(None, None, section_count), name='section_input') if not theta_student == "False": student_input = Input(batch_shape=(None, None, student_count), name='student_input') virtual_input1 = Input(batch_shape=(None, None, 1), name='virtual_input1') if finetuning: B_k = TimeDistributed(Dense( skills, activation='linear', kernel_initializer=self.f( model1.get_layer("B_k").get_weights()[0]), use_bias=False), name="B_k")(virtual_input1) T_k = TimeDistributed(Dense( skills, activation='linear', kernel_initializer=self.f( model1.get_layer("T_k").get_weights()[0]), use_bias=False), name="T_k")(virtual_input1) bias_layer = TimeDistributed(Dense( 1, activation='linear', use_bias=False, kernel_initializer=self.f( model1.get_layer("bias").get_weights()[0]), trainable=True), name="bias")(virtual_input1) else: B_k = TimeDistributed(Dense(skills, activation='linear', use_bias=False, trainable=True), name="B_k")(virtual_input1) T_k = TimeDistributed(Dense(skills, activation='linear', use_bias=False, trainable=True), name="T_k")(virtual_input1) bias_layer = TimeDistributed(Dense( 1, activation='linear', use_bias=False, kernel_initializer=initializers.Zeros(), trainable=True), name="bias")(virtual_input1) step_input = Input(batch_shape=(None, None, steps), name='step_input') if randomize: if binary == "False": Q_jk = TimeDistributed(Dense( q_jk_size, use_bias=False, activation=activation, kernel_initializer=self.custom_random), trainable=qtrainable, name="Q_jk")(step_input) else: Q_jk = TimeDistributed(BinaryDense( q_jk_size, use_bias=False, activation=activation, kernel_initializer=self.custom_random), trainable=qtrainable, name="Q_jk")(step_input) else: if binary == "False": Q_jk = TimeDistributed(Dense( skills, activation=activation, kernel_initializer=self.f(Q_jk_initialize), use_bias=False, trainable=qtrainable), trainable=qtrainable, name="Q_jk")(step_input) else: Q_jk = TimeDistributed(BinaryDense( skills, activation=activation, kernel_initializer=self.f(Q_jk_initialize), trainable=qtrainable, use_bias=False), name="Q_jk", trainable=qtrainable)(step_input) if dafm_type == "random-qjk-dense-normal" or dafm_type == "random-qjk-dense-uniform": if binary == "False": Q_jk = TimeDistributed(Dense( skills, activation=activation_dense, use_bias=False, kernel_initializer=self.custom_random, trainable=True), name="Q_jk_dense")(Q_jk) else: Q_jk = TimeDistributed(BinaryDense( skills, activation=activation_dense, use_bias=False, kernel_initializer=self.custom_random, trainable=True), name="Q_jk_dense")(Q_jk) elif dafm_type == "qjk-dense": if binary == 'False': Q_jk = TimeDistributed(Dense( skills, activation=activation_dense, use_bias=False, kernel_initializer=initializers.Identity(), trainable=True), name="Q_jk_dense")(Q_jk) else: Q_jk = TimeDistributed(BinaryDense( skills, activation=activation_dense, use_bias=False, kernel_initializer=initializers.Identity(), trainable=True), name="Q_jk_dense")(Q_jk) else: pass Qjk_mul_Bk = multiply([Q_jk, B_k]) sum_Qjk_Bk = TimeDistributed(Dense( 1, activation='linear', trainable=False, kernel_initializer=initializers.Ones(), use_bias=False), trainable=False, name="sum_Qjk_Bk")(Qjk_mul_Bk) P_k = SimpleRNN(skills, kernel_initializer=initializers.Identity(), recurrent_initializer=initializers.Identity(), use_bias=False, trainable=False, activation='linear', return_sequences=True, name="P_k")(Q_jk) Qjk_mul_Pk_mul_Tk = multiply([Q_jk, P_k, T_k]) sum_Qjk_Pk_Tk = TimeDistributed( Dense(1, activation='linear', trainable=False, kernel_initializer=initializers.Ones(), use_bias=False), trainable=False, name="sum_Qjk_Pk_Tk")(Qjk_mul_Pk_mul_Tk) Concatenate = concatenate([bias_layer, sum_Qjk_Bk, sum_Qjk_Pk_Tk]) if not (theta_student == "False"): if finetuning: theta = TimeDistributed(Dense( 1, activation="linear", use_bias=False, kernel_initializer=self.f( model1.get_layer("theta").get_weights()[0])), name='theta')(student_input) else: theta = TimeDistributed(Dense(1, activation="linear", use_bias=False), name='theta')(student_input) Concatenate = concatenate([Concatenate, theta]) if section == "onehot": if finetuning: S_k = TimeDistributed(Dense( 1, activation="linear", use_bias=False, kernel_initializer=self.f( model1.get_layer("S_k").get_weights()[0])), name='S_k')(section_input) else: S_k = TimeDistributed(Dense(1, activation="linear", use_bias=False), name='S_k')(section_input) Concatenate = concatenate([Concatenate, S_k]) output = TimeDistributed(Dense(1, activation="sigmoid", trainable=False, kernel_initializer=initializers.Ones(), use_bias=False), trainable=False, name="output")(Concatenate) if section == "onehot" and not (theta_student == "False"): model = Model(inputs=[ virtual_input1, step_input, section_input, student_input ], outputs=output) elif section == "onehot" and theta_student == "False": model = Model(inputs=[virtual_input1, step_input, section_input], outputs=output) elif not (section == "onehot") and not (theta_student == "False"): model = Model(inputs=[virtual_input1, step_input, student_input], outputs=output) else: model = Model(inputs=[virtual_input1, step_input], outputs=output) d_optimizer = { "rmsprop": optimizers.RMSprop(lr=learning_rate), "adam": optimizers.Adam(lr=learning_rate), "adagrad": optimizers.Adagrad(lr=learning_rate) } model.compile(optimizer=d_optimizer[optimizer], loss=self.custom_bce) return model
def mnist_irnn(conf, input, **kw): result_sds = kw.pop('result_sds', None) project_id = kw.pop('project_id', None) f = conf['fit'] e = conf['evaluate'] x_train = input['x_tr'] y_train = input['y_tr'] x_val = input['x_te'] y_val = input['y_te'] x_test = input['x_te'] y_test = input['y_te'] x_train = x_train.reshape(x_train.shape[0], -1, 1) x_test = x_test.reshape(x_test.shape[0], -1, 1) x_val = x_test x_train_shape = x_train.shape input_shape = x_train_shape[1:] num_classes = y_train.shape[1] hidden_units = 100 learning_rate = 1e-6 with graph.as_default(): model = Sequential() model.add( SimpleRNN( hidden_units, kernel_initializer=initializers.RandomNormal(stddev=0.001), recurrent_initializer=initializers.Identity(gain=1.0), activation='relu', input_shape=input_shape)) model.add(Dense(num_classes)) model.add(Activation('softmax')) rmsprop = RMSprop(lr=learning_rate) model.compile(loss='categorical_crossentropy', optimizer=rmsprop, metrics=['accuracy']) # callback to save metrics batch_print_callback = LambdaCallback( on_epoch_end=lambda epoch, logs: logger_service.log_epoch_end( epoch, logs, result_sds, project_id)) # checkpoint to save best weight best_checkpoint = MongoModelCheckpoint(result_sds=result_sds, verbose=0, save_best_only=True) # checkpoint to save latest weight general_checkpoint = MongoModelCheckpoint(result_sds=result_sds, verbose=0) # training history = model.fit(x_train, y_train, validation_data=(x_val, y_val), callbacks=[ batch_print_callback, best_checkpoint, general_checkpoint ], verbose=0, **f['args']) score = model.evaluate(x_test, y_test, **e['args']) # weights = model.get_weights() config = model.get_config() logger_service.log_train_end(result_sds, model_config=config, score=score, history=history.history) return {'score': score, 'history': history.history}
else: if binary=="False": Q_jk = TimeDistributed(Dense(skills, activation=activation, kernel_initializer=self.f(Q_jk_initialize), use_bias=False,trainable=qtrainable), trainable=qtrainable, name="Q_jk")(step_input) else: Q_jk = TimeDistributed(BinaryDense(skills, activation=activation, kernel_initializer=self.f(Q_jk_initialize),trainable=qtrainable, use_bias=False), name="Q_jk", trainable=qtrainable)(step_input) if dafm_type == "random-qjk-dense-normal" or dafm_type == "random-qjk-dense-uniform": if binary =="False": Q_jk = TimeDistributed(Dense(skills, activation=activation_dense, use_bias=False, kernel_initializer=self.custom_random, trainable=True), name="Q_jk_dense")(Q_jk) else: Q_jk = TimeDistributed(BinaryDense(skills, activation=activation_dense, use_bias=False, kernel_initializer=self.custom_random, trainable=True), name="Q_jk_dense")(Q_jk) elif dafm_type == "qjk-dense": if binary =='False': Q_jk = TimeDistributed(Dense(skills, activation=activation_dense, use_bias=False, kernel_initializer=initializers.Identity(), trainable=True), name="Q_jk_dense")(Q_jk) else: Q_jk = TimeDistributed(BinaryDense(skills, activation=activation_dense, use_bias=False, kernel_initializer=initializers.Identity(), trainable=True), name="Q_jk_dense")(Q_jk) else: pass Qjk_mul_Bk = multiply([Q_jk, B_k]) sum_Qjk_Bk = TimeDistributed(Dense(1, activation='linear', trainable=False, kernel_initializer=initializers.Ones(), use_bias=False), trainable=False,name="sum_Qjk_Bk")(Qjk_mul_Bk) P_k = SimpleRNN(skills, kernel_initializer=initializers.Identity(), recurrent_initializer=initializers.Identity() , use_bias=False, trainable=False, activation='linear', return_sequences=True, name="P_k")(Q_jk) Qjk_mul_Pk_mul_Tk = multiply([Q_jk, P_k, T_k]) sum_Qjk_Pk_Tk = TimeDistributed(Dense(1, activation='linear', trainable=False, kernel_initializer=initializers.Ones(), use_bias=False),trainable=False, name="sum_Qjk_Pk_Tk")(Qjk_mul_Pk_mul_Tk) Concatenate = concatenate([bias_layer, sum_Qjk_Bk, sum_Qjk_Pk_Tk]) if not (theta_student=="False"):
dict( class_name="truncated_normal", mean=0.2, stddev=0.003, seed=42), id="tn_1", ), pytest.param( initializers.Orthogonal(1.1), dict(class_name="orthogonal", gain=1.1, seed=None), id="o_0", ), pytest.param( initializers.orthogonal(gain=1.2, seed=42), dict(class_name="orthogonal", gain=1.2, seed=42), id="o_1", ), pytest.param(initializers.Identity(1.1), dict(class_name="identity", gain=1.1), id="i_0"), pytest.param(initializers.identity(), dict(class_name="identity", gain=1.0), id="i_1"), #################### VarianceScaling #################### pytest.param(initializers.glorot_normal(), dict(class_name="glorot_normal", seed=None), id="gn_0"), pytest.param(initializers.glorot_uniform(42), dict(class_name="glorot_uniform", seed=42), id="gu_0"), pytest.param(initializers.he_normal(), dict(class_name="he_normal", seed=None), id="hn_0"),