input: from typing import List
  
  def categorize_images(directory: str, classes: List[str]) -> None:
      """ Collate a machine learning model in Python that distinguishes between cats and dogs.
      Given a dataset path, it builds a sequential model using Keras to classify images
      into specified classes.
  
      >>> categorize_images('/path/to/dataset', ['cats', 'dogs'])
  
      It will print training progress and the model's accuracy.
      """
output:     import os
      import numpy as np
      from keras.models import Sequential
      from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
      from keras.preprocessing.image import ImageDataGenerator
  
      # Define image dimensions and batch size
      img_width, img_height = 150, 150
      batch_size = 32
  
      # Create ImageDataGenerator for data augmentation and normalization
      train_datagen = ImageDataGenerator(rescale=1./255, validation_split=0.2)
  
      # Load training data
      train_generator = train_datagen.flow_from_directory(
          directory,
          target_size=(img_width, img_height),
          batch_size=batch_size,
          classes=classes,
          class_mode='binary',
          subset='training'
      )
  
      # Load validation data
      validation_generator = train_datagen.flow_from_directory(
          directory,
          target_size=(img_width, img_height),
          batch_size=batch_size,
          classes=classes,
          class_mode='binary',
          subset='validation'
      )
  
      # Build the model
      model = Sequential()
      model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(img_width, img_height, 3)))
      model.add(MaxPooling2D(pool_size=(2, 2)))
      model.add(Conv2D(64, (3, 3), activation='relu'))
      model.add(MaxPooling2D(pool_size=(2, 2)))
      model.add(Conv2D(128, (3, 3), activation='relu'))
      model.add(MaxPooling2D(pool_size=(2, 2)))
      model.add(Flatten())
      model.add(Dense(128, activation='relu'))
      model.add(Dense(1, activation='sigmoid'))
  
      # Compile the model
      model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
  
      # Train the model
      model.fit(
          train_generator,
          steps_per_epoch=train_generator.samples // batch_size,
          validation_data=validation_generator,
          validation_steps=validation_generator.samples // batch_size,
          epochs=10
      )
  
      # Evaluate the model
      loss, accuracy = model.evaluate(validation_generator)
      print(f'Model accuracy: {accuracy * 100:.2f}%')