Spaceship Titanic Model

Challenge participants: Build robust spaceship titanic solutions.

Table of Contents

• Quick Start
• Introduction
• Requirements
• Project Structure
• Detailed Tutorial
• License

Quick Start

# 1. Install dependencies
pip install -r requirements.txt

# 2. Start developing your solution. Follow the tutorial below to implement your AI model

# 3. Run demo to test implement
python demo.py

Note: You need to implement your spaceship titanic solutions following the tutorial guide.

Introduction

The Spaceship Titanic Challenge is a beginner-friendly introduction to machine learning, where you’ll predict which passengers were transported to an alternate dimension during the infamous voyage. Perfect for honing your data science skills on a cosmic dataset!

AIOZ Spaceship Titanic Challenge

In this challenge, participants will be provided with:

• Code baseline to develop solutions
• Predefined libraries and tools in requirements.txt

Dataset Access: spaceship_titanic_data.

Model Access: spaceship_titanic_model.

Goal: It is your job to predict which passengers were transported to another dimension.

Requirements

System Requirements

• Python 3.10+

Dependencies

Install all required packages:

pip install -r requirements.txt

Project Structure

Your AI library should follow this structure:

repository/
├── my_ai_lib/                   # Your AI library
│   ├── __init__.py              # Required: Library initialization
│   ├── run.py                   # Required: Main workflow function
│   └── [your_modules]/          # Your custom modules
├── models/                      # Model weights directory
├── demo.py                      # Demo script
├── requirements.txt             # Dependencies
└── README.md                    # Documentation

Key Components

Component	Description	Status
my_ai_lib/	Core AI library directory	Required
my_ai_lib/__init__.py	Library initialization	Required
my_ai_lib/run.py	Main AI workflow	Required
demo.py	Demo and testing script	Required

Detailed Tutorial

Step 1: Initialize Your AI Library

1.1 Define my_ai_lib/__init__.py

from .run import run

This file defines that the run() function in run.py as an attribute of the my_ai_lib and that I can call it by my_ai_lib.run()

1.2 Define Input/Output Objects in my_ai_lib/run.py

Create your custom input and output classes:

from pathlib import Path
from typing import Any, Union, Literal
from aioz_ainode_adapter.schemas import InputObject, OutputObject, FileObject


class MyInput(InputObject):
    input_image: str
    example_param: Any


class MyOutput(OutputObject):
    text: str
    output_image: FileObject

Step 2: Understanding AIOZ Schema Objects

The aioz_ainode_adapter library defines 3 core object types based on pydantic.BaseModel:

🔸 InputObject

Define the format for input when the AIOZ-AI-Node system sends to your AI library.

Default Parameters:

Parameter	Type	Description
device	Choice	Device for your model: ["cuda", "cpu", "gpu"]
model_storage_directory	String	Directory containing model weights

Important : Always use model_storage_directory for model weight paths, as AIOZ-AI-Node will specify this location.

🔸 OutputObject

Define the format for output when your AI library sends to the AIOZ-AI-Node system.

🔸 FileObject

Define the format for the file, if your output has a file. This object has two fields:

Field	Type	Description
data	Choice	File data: io.BufferedReader, Path, or URL
name	String	File name

Example FileObject creation:

output_file = FileObject(data=open("file/path.csv", "rb"), name="output.csv")

Note:

• Input files must be local file paths or URLs
• Output files must be FileObject instances

Step 3: Implement the Main Workflow

3.1 Define Your AI Task Function

def do_ai_task(
        input_image: Union[str, Path],
        example_param: Any,
        model_storage_directory: Union[str, Path],
        device: Literal["cpu", "cuda", "gpu"] = "cpu",
        *args, **kwargs) -> Any:
    """
    Define AI task: load model, pre-process, post-process, etc.
    
    Args:
        input_image: Path to input image
        example_param: Example parameter
        model_storage_directory: Directory containing model weights
        device: Computing device
        
    Returns:
        Result
    """
    # Define your AI task workflow. Below is an example
    text = "This is the AI task result"
    output_image = open("wiki/aioz.png", "rb")  # io.BufferedReader
    return text, output_image

3.2 Implement the Required run() Function

def run(input_obj: InputObject) -> OutputObject:
    """
    Main entry point for your AI library.
    
    Args:
        input_obj: Input object containing all parameters
        
    Returns:
        OutputObject: Results of AI processing
    """
    # Validate and parse input
    my_input = MyInput.model_validate(input_obj.model_dump())
    print(f"Input: {my_input}")

    # Execute AI task
    text, output_image = do_ai_task(
        input_image=my_input.input_image,
        example_param=my_input.example_param,
        model_storage_directory=my_input.model_storage_directory,
        device=my_input.device
    )

    # Create output object
    output_file = FileObject(data=output_image, name="output_image.png")
    output_obj = MyOutput(text=text, output_image=output_file)
    return output_obj

Critical: The run() function name is mandatory and cannot be changed. The do_ai_task() function can be renamed and customized.

Step 4: Create Demo Script

Create demo.py to test your implementation:

import my_ai_lib
from aioz_ainode_adapter.schemas import InputObject


def main():
    """Demo function to test your AI library."""
    input_obj = InputObject(
        input_image="wiki/aioz.png", 
        example_param="example"
    )
    output_obj = my_ai_lib.run(input_obj)
    print(f"Output: {output_obj}")


if __name__ == '__main__':
    main()

The my_ai_lib.run() function receives an InputObject and returns an OutputObject.

Expected console output:

Input: type='InputObj' device='cuda' model_storage_directory='models' input_image='wiki/aioz.png' example_param='example'
Output: type='OutputObj' text='This is the AI task result' output_image=FileObject(type='FileObj', data=<_io.BufferedReader name='wiki/aioz.png'>, name='output_image.png')

Step 5: Add Model Weights

Place your trained model files in the models/ directory:

models/
├── model.pth          # Your trained model
├── config.json        # Model configuration
└── etc.

Step 6: Run demo

Run this command to test your implementation

python demo.py

Submission format

The submission file has two field:

• PassengerId: The unique identifier/index corresponding to each passenger
• Transported: Your model’s prediction (True or False) for each passenger.

Example:

	PassengerId,Transported
	123, True
	124, False

License

This repository is licensed under the MIT License.