TF2DeepFloorplan

https://github.com/zcemycl/tf2deepfloorplan
Admin
TF2DeepFloorplan is a TensorFlow 2 implementation of a deep learning model for floor plan...
Tokens:11,092
Snippets:107
Trust Score:8.3
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example Training Command

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

An example command to start training the model with specific batch size, learning rate, and epochs. Ensure log and model directories are correctly specified.

```bash
python -m dfp.train --batchsize=4 --lr=5e-4 --epochs=100
--logdir=log/store --modeldir=model/store
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs the project dependencies including optional features for GPU, API, development, testing, and linting. Also installs and configures pre-commit hooks for code quality.

```bash
pip install -e .[tfgpu,api,dev,testing,linting]
pre-commit install
pre-commit run
pre-commit run --all-files
# pre-commit uninstall/ pip uninstall pre-commit
```

--------------------------------

### Install TF2DeepFloorplan dependencies

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Clones the repository and installs necessary packages for the environment.

```bash
!git clone -b main https://github.com/zcemycl/TF2DeepFloorplan.git
!pip install gdown
!pip install --upgrade --no-cache-dir gdown
!gdown https://drive.google.com/uc?id=1czUSFvk6Z49H-zRikTc67g2HUUz4imON
!unzip log.zip
!rm log.zip
```

--------------------------------

### Example Deployment Command

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

An example command to deploy the model for inference on a given image. It specifies the input image, weight file, output path, and loading method.

```bash
python -m dfp.deploy --image floorplan.jpg --weight log/store/G
--postprocess --colorize --save output.jpg --loadmethod log
```

--------------------------------

### Install package requirements

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Installs the package in editable mode with CPU support.

```bash
# gpu
# !cd TF2DeepFloorplan && pip install -e .[tfgpu]
# cpu
!cd TF2DeepFloorplan && pip install -e .[tfcpu]
```

--------------------------------

### Install TF2DeepFloorplan for Everything

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs all available dependencies including TensorFlow GPU, API, development, testing, linting, and game support. Use this for comprehensive development and deployment.

```bash
pip install -e .[tfgpu,api,dev,testing,linting,game]
```

--------------------------------

### Initialize and Run Deep Floor Plan Model

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Setup the VGG16-based model, load weights, and perform inference on input images.

```python
import tensorflow as tf
from argparse import Namespace
from dfp.net import deepfloorplanModel

# Initialize model with default VGG16 backbone
config = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='vgg16',
    feature_names=['block1_pool', 'block2_pool', 'block3_pool', 'block4_pool', 'block5_pool']
)
model = deepfloorplanModel(config=config)

# Build model and load weights
model.build((1, 512, 512, 3))
model.load_weights('log/store/G')

# Run inference
img = tf.random.uniform([1, 512, 512, 3], 0, 1)
logits_room, logits_boundary = model(img)
# logits_room: (1, 512, 512, 9) - 9 room type classes
# logits_boundary: (1, 512, 512, 3) - 3 boundary classes (background, opening, wall)

# Get class predictions
room_pred = tf.argmax(logits_room, axis=-1)  # (1, 512, 512)
boundary_pred = tf.argmax(logits_boundary, axis=-1)  # (1, 512, 512)
```

--------------------------------

### Install Rectangle via Homebrew

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/MacOS-setup

Install the Rectangle window management application using Homebrew Cask.

```bash
brew install --cask rectangle
```

--------------------------------

### Install TF2DeepFloorplan for Game

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs the package with TensorFlow GPU and game dependencies. Use this to enable the pygame-based visualization and interaction.

```bash
pip install -e .[tfgpu,game]
```

--------------------------------

### Install TF2DeepFloorplan for Notebooks

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs the package with TensorFlow GPU and Jupyter notebook support. This is ideal for running and experimenting with the models in a notebook environment.

```bash
pip install -e .[tfgpu,jupyter]
```

--------------------------------

### Install TF2DeepFloorplan with CPU Support

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs the package with TensorFlow CPU, development tools, testing, and linting dependencies. Use this for model development on systems without a compatible GPU.

```bash
pip install -e .[tfcpu,dev,testing,linting]
```

--------------------------------

### TOML Configuration Example

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Illustrates the structure of a TOML configuration file used by TF2DeepFloorplan for experiments, covering training, deployment, and conversion parameters.

```toml
# tfmodel = 'subclass'
# image = 'resources/example5.jpg'
# CASTED_RAYS = 150
# postprocess = 1
# colorize = 0
# weight = 'model/store_vgg16_exp2_model.tflite'
# loadmethod = 'tflite'
# feature_channels = [32, 32, 32, 32]
# backbone = 'vgg16'
```

--------------------------------

### Install TF2DeepFloorplan for Model Deployment API

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs the package with TensorFlow GPU and API dependencies. This is suitable for deploying the trained model as an API service.

```bash
pip install -e .[tfgpu,api]
```

--------------------------------

### Install TF2DeepFloorplan with GPU Support

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs the package with TensorFlow GPU, development tools, testing, and linting dependencies. This is recommended for model development when a compatible GPU is available.

```bash
pip install -e .[tfgpu,dev,testing,linting]
```

--------------------------------

### Create and Activate Virtual Environment

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Sets up a Python virtual environment using venv and installs the latest package management tools. This is a standard practice for managing project dependencies.

```bash
python -m venv venv
source venv/bin/activate
pip install --upgrade pip setuptools wheel
```

--------------------------------

### Install TensorFlow with Metal Plugin

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/MacOS-setup

Install TensorFlow dependencies and the macOS and Metal packages for GPU acceleration.

```bash
conda install -c apple tensorflow-deps
python3 -m pip install tensorflow-macos tensorflow-metal
```

--------------------------------

### Common Package Installation

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs common packages including TensorFlow GPU, API, development, testing, and linting tools. This command should be run after activating your virtual environment.

```bash
pip install -e .[tfgpu,api,dev,testing,linting]
```

--------------------------------

### Install TF2DeepFloorplan for M1 Chip

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Installs the package with TensorFlow support for M1 chips, along with development, testing, and linting dependencies. Use this for model development on MacOS with M1 hardware.

```bash
pip install -e .[tfmacm1,dev,testing,linting]
```

--------------------------------

### Manage Flask REST API Server

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Commands to start the API server, run it via Docker, and interact with endpoints for image processing.

```bash
# Start the API server
python -m dfp.app
# Server runs on http://0.0.0.0:1111

# Or run with Docker
docker build -t tf_docker -f Dockerfile .
docker run -d -p 1111:1111 tf_docker:latest
# With GPU support
docker run --gpus all -d -p 1111:1111 tf_docker:latest

# Health check endpoint
curl http://0.0.0.0:1111/
# Response: {"message": "Hello Flask!"}

# Process image from URL with colorization
curl -H "Content-Type: application/json" --request POST \
    -d '{"uri":"https://example.com/floorplan.jpg","colorize":1,"postprocess":0}' \
    http://0.0.0.0:1111/uri --output result.jpg

# Process image from URL with post-processing
curl -H "Content-Type: application/json" --request POST \
    -d '{"uri":"https://example.com/floorplan.jpg","colorize":1,"postprocess":1}' \
    http://0.0.0.0:1111/uri --output result.jpg

# Upload image file directly
curl --request POST \
    -F "file=@resources/30939153.jpg" \
    -F "postprocess=1" \
    -F "colorize=1" \
    http://0.0.0.0:1111/upload --output output.jpg

# Upload without post-processing
curl --request POST \
    -F "file=@floorplan.png" \
    -F "postprocess=0" \
    -F "colorize=0" \
    http://0.0.0.0:1111/upload --output raw_output.jpg
```

--------------------------------

### Clean Up Brew Packages

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/MacOS-setup

Use brew commands to find package details, list installed packages, and clean up old versions.

```bash
brew info {package} # find location and details
brew list
brew cleanup
```

--------------------------------

### Run Tensorboard for Visualization

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Launches Tensorboard to visualize the training progress, including loss and image metrics. Point it to the directory where training logs are stored.

```bash
tensorboard --logdir=log/store
```

--------------------------------

### Initialize environment and imports

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Imports required libraries and configures TensorFlow GPU settings.

```python
import tensorflow as tf
import sys
from dfp.net import *
from dfp.data import *
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
from argparse import Namespace
import os
import gc
os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'
from dfp.utils.rgb_ind_convertor import *
from dfp.utils.util import *
from dfp.utils.legend import *
from dfp.utils.settings import *
from dfp.deploy import *
print(tf.test.is_gpu_available())
print(tf.config.list_physical_devices('GPU'))
```

--------------------------------

### Download Model Weights (PB files)

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Downloads pre-trained model weights in Protocol Buffer (pb) format (107.3mb) from Google Drive. These are used for model deployment.

```bash
gdown https://drive.google.com/uc?id=1tuqUPbiZnuubPFHMQqCo1_kFNKq4hU8i # pb files 107.3mb
unzip model.zip
```

--------------------------------

### Deploy the Trained Model

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Deploys the trained floor plan recognition model for inference. Ensure the 'loadmethod' and 'weight' parameters match the model format you are using.

```bash
python -m dfp.deploy [--image 'path/to/image']
[--postprocess][--colorize][--save 'path/to/output_image']
[--loadmethod 'log'/'pb'/'tflite']
[--weight 'log/store/G'/'model/store'/'model/store/model.tflite']
[--tfmodel 'subclass'/'func']
[--feature-channels 256 128 64 32]
[--backbone 'vgg16'/'mobilenetv1'/'mobilenetv2'/'resnet50']
[--feature-names block1_pool block2_pool block3_pool block4_pool block5_pool]
```

--------------------------------

### Run Interactive 3D Floor Plan Visualization

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Launches an interactive pygame visualization of floor plans in 3D using raycasting. Users can navigate in first-person. Configuration can be done via TOML file or programmatically.

```python
# Run the interactive visualization from command line
python -m dfp.game

# Configuration via TOML file (docs/game.toml)
# tfmodel = 'subclass'
# image = 'resources/example5.jpg'
# CASTED_RAYS = 150
# postprocess = 1
# colorize = 0
# weight = 'model/store_vgg16_exp2_model.tflite'
# loadmethod = 'tflite'
# feature_channels = [32, 32, 32, 32]
# backbone = 'vgg16'

# Programmatic usage
from dfp.game import Game

# Initialize with custom configuration
game = Game(tomlfile='docs/game.toml')

# Run the game loop
# Controls: Arrow keys or WASD for movement
# The display shows:
# - Left half: 2D floor plan with player position and rays
# - Right half: 3D raycasted view of walls
game.run()

# Custom game model configuration
from dfp.game.model import Model
from dfp.game.view import View
from dfp.game.controller import Controller

model = Model(tomlfile='docs/game.toml')
print(f"Map dimensions: {model.w}x{model.h}")
print(f"Player position: ({model.player_x}, {model.player_y})")
print(f"Field of view: {model.FOV} radians")
```

--------------------------------

### Load image and configuration

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Loads an image and parses the TOML configuration file.

```python
img_path = './TF2DeepFloorplan/resources/30939153.jpg'
inp = mpimg.imread(img_path)
args = parse_args("--tomlfile ./TF2DeepFloorplan/docs/notebook.toml".split())
args = overwrite_args_with_toml(args)
args.image = img_path
```

--------------------------------

### Execution Commands

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

CLI commands to run training, deployment, and conversion tasks using the specified TOML files.

```bash
python -m dfp.train --tomlfile=docs/experiments/vgg16/exp1/train.toml
python -m dfp.deploy --tomlfile=docs/experiments/vgg16/exp1/deploy.toml
python -m dfp.convert2tflite --tomlfile=docs/experiments/vgg16/exp1/compress.toml
```

--------------------------------

### Build and Run Docker Container

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Builds the Docker image and runs the container. Use `--gpus all` for GPU support. For hot reloading Flask, mount the application and deploy scripts.

```bash
docker build -t tf_docker -f Dockerfile .
docker run -d -p 1111:1111 tf_docker:latest
docker run --gpus all -d -p 1111:1111 tf_docker:latest

# special for hot reloading flask
docker run -v ${PWD}/src/dfp/app.py:/src/dfp/app.py -v ${PWD}/src/dfp/deploy.py:/src/dfp/deploy.py -d -p 1111:1111 tf_docker:latest
```

```bash
docker logs `docker ps | grep "tf_docker:latest"  | awk '{ print $1 }'` --follow
```

--------------------------------

### Run Pygame Visualization

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Launches the pygame-based application for visualizing and interacting with floor plans. This provides a game-like interface for exploring the model's capabilities.

```bash
python -m dfp.game
```

--------------------------------

### Deploy Floor Plan Recognition Model

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Perform inference on floor plan images using trained models. Supports loading from checkpoint logs, SavedModel, or TFLite formats. Options include post-processing for cleaner boundaries and colorization for visualization. The output can be raw class indices or colorized RGB images. Programmatic usage is also available via the `dfp.deploy.main` function.

```bash
python -m dfp.deploy --image=floorplan.jpg --weight=log/store/G \
    --loadmethod=log --save=output.jpg
```

```bash
python -m dfp.deploy --image=resources/30939153.jpg \
    --weight=log/store/G --loadmethod=log \
    --postprocess --colorize --save=result.jpg
```

```bash
python -m dfp.deploy --image=input.jpg --weight=model/store \
    --loadmethod=pb --postprocess --colorize --save=output.jpg
```

```bash
python -m dfp.deploy --image=input.jpg \
    --weight=model/store/model.tflite --loadmethod=tflite \
    --tfmodel=func --postprocess --colorize --save=output.jpg
```

```python
from argparse import Namespace
from dfp.deploy import main

config = Namespace(
    tfmodel='subclass',
    image='floorplan.jpg',
    weight='log/store/G',
    loadmethod='log',
    postprocess=True,
    colorize=True,
    save='output.jpg',
    feature_channels=[256, 128, 64, 32],
    backbone='vgg16',
    feature_names=['block1_pool', 'block2_pool', 'block3_pool', 'block4_pool', 'block5_pool']
)
result = main(config)  # Returns numpy array of shape (H, W, 3)
```

--------------------------------

### Compress Model with Weight Clustering

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Use the conversion script to apply weight clustering for model compression.

```bash
python -m dfp.convert2tflite --modeldir=model/store \
    --compress-mode=cluster --tfmodel=func --loadmethod=pb
```

--------------------------------

### Initialize model and predict

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Initializes the model and performs initial prediction.

```python
model,img,shp = init(args)
logits_cw,logits_r = predict(model,img,shp)
```

--------------------------------

### Train the Deep Floor Plan Recognition Model

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Initiates the training process for the DNN model. Model checkpoints are stored in 'log/store' and weights in 'model/store'. Customize training parameters as needed.

```bash
python -m dfp.train [--batchsize 2][--lr 1e-4][--epochs 1000]
[--logdir 'log/store'][--modeldir 'model/store']
[--save-tensor-interval 10][--save-model-interval 20]
[--tfmodel 'subclass'/'func'][--feature-channels 256 128 64 32]
[--backbone 'vgg16'/'mobilenetv1'/'mobilenetv2'/'resnet50']
[--feature-names block1_pool block2_pool block3_pool block4_pool block5_pool]
```

--------------------------------

### Download Log Files

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Downloads pre-trained log files (112.5mb) from Google Drive. These files are typically used for resuming training or analysis.

```bash
gdown https://drive.google.com/uc?id=1czUSFvk6Z49H-zRikTc67g2HUUz4imON # log files 112.5mb
unzip log.zip
```

--------------------------------

### Remove Cache and Build Artifacts

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/MacOS-setup

Find and remove common cache and build artifact directories like __pycache__, .pyc, .pyo, and .terraform.

```bash
find . | grep -E "(/__pycache__$|\.pyc$|\.pyo$|\.terraform$)" | xargs rm -rf
```

--------------------------------

### Load Datasets

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Load floor plan datasets from TFRecords format.

```python
import tensorflow as tf
from dfp.data import loadDataset, decodeAllRaw, preprocess, convert_one_hot_to_image

# Load dataset from TFRecords
dataset = loadDataset()  # Expects 'r3d.tfrecords' in current directory
```

--------------------------------

### Data Loading and Preprocessing

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Utilities for loading floor plan datasets from TFRecords format and preprocessing images for model training and inference.

```APIDOC
## Load Dataset

### Description
Loads a floor plan dataset from TFRecords files.

### Method
Function Call

### Parameters
None

### Request Example
```python
import tensorflow as tf
from dfp.data import loadDataset

dataset = loadDataset() # Expects 'r3d.tfrecords' in current directory
```

### Response
#### Success Response
- A TensorFlow dataset object containing the floor plan data.
```

--------------------------------

### Deployment Configuration (TOML)

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Specifies model loading and post-processing parameters for deployment.

```toml
tfmodel = 'subclass'
image = ''
postprocess = 1
colorize = 1
save = ''
weight = 'log/store/G'
loadmethod = 'log'
feature_channels = [256, 128, 64, 32]
backbone = 'vgg16'
feature_names = ["block1_pool", "block2_pool", "block3_pool", "block4_pool", "block5_pool"]
```

--------------------------------

### Visualize input and output

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Displays the input image and the model result side-by-side.

```python
plt.subplot(1,2,1)
plt.imshow(inp); plt.xticks([]); plt.yticks([]);
plt.subplot(1,2,2)
plt.imshow(result); plt.xticks([]); plt.yticks([]);
```

--------------------------------

### Train Floor Plan Recognition Model

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Use this command to train a floor plan recognition model. Specify batch size, learning rate, epochs, and log/model directories. Different backbones like VGG16 or MobileNetV1 can be selected for varying model sizes and performance characteristics. TOML configuration files enable reproducible experiments. Monitor training with TensorBoard.

```bash
python -m dfp.train --batchsize=4 --lr=5e-4 --epochs=100 \
    --logdir=log/store --modeldir=model/store
```

```bash
python -m dfp.train --batchsize=4 --lr=1e-4 --epochs=200 \
    --backbone=mobilenetv1 \
    --feature-channels 256 128 64 32 \
    --feature-names conv_pw_1_relu conv_pw_3_relu conv_pw_5_relu conv_pw_7_relu conv_pw_13_relu \
    --logdir=log/mobilenet --modeldir=model/mobilenet
```

```bash
python -m dfp.train --tomlfile=docs/experiments/vgg16/exp1/train.toml
```

```bash
tensorboard --logdir=log/store
```

--------------------------------

### Training Configuration (TOML)

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Defines hyperparameters and model architecture for training sessions.

```toml
tfmodel = 'func'
batchsize = 8
lr = 1e-4
epochs = 100
logdir = 'log/store_vgg16_exp1'
modeldir = 'model/store_vgg16_exp1'
save_tensor_interval = 10
save_model_interval = 20
feature_channels = [256, 128, 64, 32]
backbone = 'vgg16'
feature_names = ["block1_pool", "block2_pool", "block3_pool", "block4_pool", "block5_pool"]
```

--------------------------------

### Convert models to TFLite

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/Archive

Executes the conversion script with specified model architecture, compression strategy, and source directory.

```bash
python -m  dfp.convert2tflite --tfmodel func --compress-mode prune --modeldir log/store_re_func1/G --loadmethod log
python -m  dfp.convert2tflite --tfmodel func --compress-mode prune --modeldir model/store_re_func1 --loadmethod pb
python -m  dfp.convert2tflite --tfmodel func --compress-mode cluster --modeldir log/store_re_func1/G --loadmethod log
```

--------------------------------

### Create Feature Branch

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Fetches the latest changes from the origin and checks out a new branch for feature development.

```bash
git fetch origin
git checkout xx-features
```

--------------------------------

### Compression Configuration (TOML)

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Configures model quantization and TFLite conversion settings.

```toml
modeldir = 'model/store_vgg16_exp1'
tflitedir = 'model/store_vgg16_exp1_model.tflite'
loadmethod = 'pb'
quantize = true
feature_channels = [256, 128, 64, 32]
backbone = 'vgg16'
feature_names = ["block1_pool", "block2_pool", "block3_pool", "block4_pool", "block5_pool"]
```

--------------------------------

### Call API via File Upload

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Uploads a local image file to the API for processing. The `postprocess` and `colorize` flags can be set to 0 or 1. This endpoint may not work if running `app.py` without Docker.

```bash
curl --request POST -F "file=@resources/30939153.jpg" \
  -F "postprocess=0" -F "colorize=0" http://0.0.0.0:1111/upload --output out.jpg
```

--------------------------------

### Visualize fused result

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Displays the combined colorized room and wall/door map.

```python
plt.imshow(newr_color+newcw_color); plt.xticks([]); plt.yticks([]);
```

--------------------------------

### Create and Activate Conda Environment

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Creates a Conda environment named 'venv' with Python 3.8, CUDA 10.1, and cuDNN 7.6.5, then activates it. This is preferred for managing GPU-specific dependencies.

```bash
conda create -n venv python=3.8 cudatoolkit=10.1
cudnn=7.6.5
conda activate venv
```

--------------------------------

### Configure Functional Model API

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Initialize models with different backbone architectures using the functional Keras API.

```python
import tensorflow as tf
from argparse import Namespace
from dfp.net_func import deepfloorplanFunc

# VGG16 backbone (default)
config_vgg = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='vgg16',
    feature_names=['block1_pool', 'block2_pool', 'block3_pool', 'block4_pool', 'block5_pool']
)
model_vgg = deepfloorplanFunc(config=config_vgg)

# MobileNetV1 backbone (smaller model)
config_mobilenet = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='mobilenetv1',
    feature_names=['conv_pw_1_relu', 'conv_pw_3_relu', 'conv_pw_5_relu', 'conv_pw_7_relu', 'conv_pw_13_relu']
)
model_mobilenet = deepfloorplanFunc(config=config_mobilenet)

# MobileNetV2 backbone
config_mobilenetv2 = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='mobilenetv2',
    feature_names=['block_1_expand_relu', 'block_3_expand_relu', 'block_6_expand_relu', 'block_13_expand_relu', 'out_relu']
)
model_mobilenetv2 = deepfloorplanFunc(config=config_mobilenetv2)

# ResNet50 backbone (larger model)
config_resnet = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='resnet50',
    feature_names=['conv1_relu', 'conv2_block3_out', 'conv3_block4_out', 'conv4_block6_out', 'conv5_block3_out']
)
model_resnet = deepfloorplanFunc(config=config_resnet)

# Inference with functional model
img = tf.random.uniform([1, 512, 512, 3], 0, 1)
logits_room, logits_boundary = model_vgg.predict(img)
```

--------------------------------

### Call API via URL

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Sends a POST request with a JSON payload containing an image URI to the API for processing. The output is saved to a file.

```bash
curl -H "Content-Type: application/json" --request POST  \
  -d '{"uri":"https://cdn.cnn.com/cnnnext/dam/assets/200212132008-04-london-rental-market-intl-exlarge-169.jpg","colorize":1,"postprocess":0}' \
  http://0.0.0.0:1111/uri --output /tmp/tmp.jpg
```

--------------------------------

### Regenerate Poetry lock file

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/Hate-my-git-practice

Update the project environment and regenerate the lock file using Poetry.

```bash
poetry install
poetry lock
```

--------------------------------

### Download TFLite Model File

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Downloads a pre-trained TensorFlow Lite model file (37.1mb) from Google Drive. This file is ready for deployment on compatible platforms.

```bash
gdown https://drive.google.com/uc?id=1B-Fw-zgufEqiLm00ec2WCMUo5E6RY2eO # tfilte file 37.1mb
unzip tflite.zip
```

--------------------------------

### Deep Floor Plan Model (Class API)

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Implementation of the multi-task neural network for floor plan recognition using a class-based Keras API. Supports VGG16 backbone and outputs room type and boundary predictions.

```APIDOC
## Initialize and Build Model

### Description
Initializes the `deepfloorplanModel` with a specified configuration and loads pre-trained weights.

### Method
Instantiation and `build`/`load_weights`

### Parameters
#### Configuration (`config` Namespace)
- **feature_channels** (list of int) - Channels for feature maps.
- **backbone** (string) - Backbone architecture (e.g., 'vgg16').
- **feature_names** (list of string) - Names of features to extract from the backbone.

#### Weights
- Path to pre-trained weights (e.g., 'log/store/G').

### Request Example
```python
import tensorflow as tf
from argparse import Namespace
from dfp.net import deepfloorplanModel

config = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='vgg16',
    feature_names=['block1_pool', 'block2_pool', 'block3_pool', 'block4_pool', 'block5_pool']
)
model = deepfloorplanModel(config=config)
model.build((1, 512, 512, 3))
model.load_weights('log/store/G')
```

### Response
#### Success Response
- A compiled `deepfloorplanModel` instance ready for inference.

#### Inference Output
- **logits_room** (tensor) - Logits for room type prediction (shape: [batch_size, height, width, num_room_classes]).
- **logits_boundary** (tensor) - Logits for boundary prediction (shape: [batch_size, height, width, num_boundary_classes]).
```

--------------------------------

### Post-process predictions

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Refines the room and wall/door predictions using post-processing.

```python
newr,newcw = post_process(r,cw,shp)
plt.subplot(1,2,1)
plt.imshow(newr.squeeze()); plt.xticks([]); plt.yticks([]);
plt.subplot(1,2,2)
plt.imshow(newcw.squeeze()); plt.xticks([]); plt.yticks([]);
```

--------------------------------

### Run model inference

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Executes the main inference function with the provided arguments.

```python
result = main(args)
```

--------------------------------

### Colorize predictions

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Applies color mapping to the room and wall/door predictions.

```python
r_color,cw_color = colorize(r.squeeze(),cw.squeeze())
plt.subplot(1,2,1)
plt.imshow(r_color); plt.xticks([]); plt.yticks([]);
plt.subplot(1,2,2)
plt.imshow(cw_color); plt.xticks([]); plt.yticks([]);
```

--------------------------------

### Generate legend

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Creates and displays a legend for the floorplan visualization.

```python
over255 = lambda x: [p/255 for p in x]
colors2 = [over255(rgb) for rgb in list(floorplan_fuse_map.values())]
colors = ["background", "closet", "bathroom",
          "living room\nkitchen\ndining room",
          "bedroom","hall","balcony","not used","not used",
          "door/window","wall"]
f = lambda m,c: plt.plot([],[],marker=m, color=c, ls="none")[0]
handles = [f("s", colors2[i]) for i in range(len(colors))]
labels = colors
legend = plt.legend(handles, labels, loc=3,framealpha=1, frameon=True)

fig  = legend.figure
fig.canvas.draw()
plt.xticks([]); plt.yticks([]);
```

--------------------------------

### Rank File Size

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/MacOS-setup

Rank directories by size in human-readable format to identify large files.

```bash
du -h -d 1 | sort -h
```

--------------------------------

### Convert Class Indices to RGB Visualization

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Utilizes predefined color maps to convert class indices for rooms, boundaries, and fused maps into RGB images. Also demonstrates converting RGB back to indices.

```python
import numpy as np
from dfp.utils.rgb_ind_convertor import (
    ind2rgb, rgb2ind,
    floorplan_room_map,
    floorplan_boundary_map,
    floorplan_fuse_map
)

# Room type color map (9 classes)
# 0: background (black), 1: closet, 2: bathroom, 3: living room
# 4: bedroom, 5: hall, 6: balcony, 7-8: unused

# Boundary color map (3 classes)
# 0: background, 1: opening (door/window), 2: wall

# Convert class indices to RGB visualization
room_indices = np.random.randint(0, 9, (512, 512))
room_rgb = ind2rgb(room_indices, color_map=floorplan_room_map)
print(f"Room RGB shape: {room_rgb.shape}")  # (512, 512, 3)

boundary_indices = np.random.randint(0, 3, (512, 512))
boundary_rgb = ind2rgb(boundary_indices, color_map=floorplan_boundary_map)

# Fused map combines room and boundary labels (11 classes)
# Classes 9-10 are opening and wall overlaid on rooms
fused_indices = np.random.randint(0, 11, (512, 512))
fused_rgb = ind2rgb(fused_indices, color_map=floorplan_fuse_map)

# Convert RGB back to indices
recovered_indices = rgb2ind(room_rgb.astype(np.uint8), color_map=floorplan_room_map)
```

--------------------------------

### Squash commits with Git rebase

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/Hate-my-git-practice

Use interactive rebase to squash multiple commits into one. Requires manual intervention in the editor to set commit actions.

```bash
git log # to find a base
git rebase {hash} -i
# within the vim
%s/pick/fixup/g
- the first one to turn back to pick
# 
git diff origin/features/brancha --name-only # to check changed file names
```

--------------------------------

### Compute Balanced Cross-Entropy Loss

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Calculates balanced cross-entropy loss for room and boundary segmentation tasks, and computes multi-task weights based on label distribution. Combines losses with weights.

```python
import tensorflow as tf
from dfp.loss import balanced_entropy, cross_two_tasks_weight

# Simulated model outputs and ground truth
logits_room = tf.random.uniform([4, 512, 512, 9])
logits_boundary = tf.random.uniform([4, 512, 512, 3])
gt_room = tf.one_hot(tf.random.uniform([4, 512, 512], 0, 9, dtype=tf.int32), 9)
gt_boundary = tf.one_hot(tf.random.uniform([4, 512, 512], 0, 3, dtype=tf.int32), 3)

# Compute balanced entropy loss for each task
loss_room = balanced_entropy(logits_room, gt_room)
loss_boundary = balanced_entropy(logits_boundary, gt_boundary)

# Compute task weights based on label distribution
w1, w2 = cross_two_tasks_weight(gt_room, gt_boundary)

# Combined multi-task loss
total_loss = w1 * loss_room + w2 * loss_boundary
print(f"Room loss: {loss_room.numpy():.4f}")
print(f"Boundary loss: {loss_boundary.numpy():.4f}")
print(f"Task weights: w1={w1.numpy():.4f}, w2={w2.numpy():.4f}")
print(f"Total loss: {total_loss.numpy():.4f}")
```

--------------------------------

### Convert Model to TFLite Format

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

Converts the trained model to the TensorFlow Lite format for deployment on edge devices. Specify the model directory, output TFLite path, and loading method.

```bash
python -m dfp.convert2tflite [--modeldir model/store]
[--tflitedir model/store/model.tflite]
[--loadmethod 'log'/'none'/'pb']
[--quantize][--tfmodel 'subclass'/'func']
[--feature-channels 256 128 64 32]
[--backbone 'vgg16'/'mobilenetv1'/'mobilenetv2'/'resnet50']
[--feature-names block1_pool block2_pool block3_pool block4_pool block5_pool]
```

--------------------------------

### Flask REST API Endpoints

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

The Flask application provides REST endpoints for floor plan recognition. It supports processing images from URLs or file uploads, with options for post-processing and colorization. Responses are returned as JPEG images.

```APIDOC
## Health Check Endpoint

### Description
Checks if the API server is running.

### Method
GET

### Endpoint
/

### Response
#### Success Response (200)
- **message** (string) - A confirmation message.

#### Response Example
```json
{
  "message": "Hello Flask!"
}
```
```

```APIDOC
## Process Image from URL

### Description
Processes an image from a given URL. Supports optional colorization and post-processing.

### Method
POST

### Endpoint
/uri

### Parameters
#### Request Body
- **uri** (string) - Required - The URL of the image to process.
- **colorize** (integer) - Optional - Whether to colorize the output. 1 for enabled, 0 for disabled.
- **postprocess** (integer) - Optional - Whether to apply post-processing. 1 for enabled, 0 for disabled.

### Request Example
```json
{
  "uri": "https://example.com/floorplan.jpg",
  "colorize": 1,
  "postprocess": 0
}
```

### Response
#### Success Response (200)
- The response is the processed image in JPEG format.

#### Response Example
(Binary JPEG data)
```

```APIDOC
## Upload Image File

### Description
Uploads an image file for processing. Supports optional post-processing and colorization.

### Method
POST

### Endpoint
/upload

### Parameters
#### Request Body
- **file** (file) - Required - The image file to upload.
- **postprocess** (integer) - Optional - Whether to apply post-processing. 1 for enabled, 0 for disabled.
- **colorize** (integer) - Optional - Whether to colorize the output. 1 for enabled, 0 for disabled.

### Request Example
```bash
curl --request POST \
    -F "file=@resources/30939153.jpg" \
    -F "postprocess=1" \
    -F "colorize=1" \
    http://0.0.0.0:1111/upload --output output.jpg
```

### Response
#### Success Response (200)
- The response is the processed image in JPEG format.

#### Response Example
(Binary JPEG data)
```

--------------------------------

### Process Batches for Training

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Iterates through a shuffled dataset in batches, decodes raw tensors, and preprocesses images and labels for training. Prints shapes of processed tensors.

```python
for data in dataset.shuffle(400).batch(4):
    # Decode raw tensors
    img, boundary, room = decodeAllRaw(data)

    # Preprocess: normalize images, create one-hot labels
    img, boundary, room, hot_boundary, hot_room = preprocess(img, boundary, room)
    # img: (batch, 512, 512, 3) float32 normalized to [0,1]
    # boundary: (batch, 512, 512) uint8 class indices
    # room: (batch, 512, 512) uint8 class indices
    # hot_boundary: (batch, 512, 512, 3) one-hot encoded
    # hot_room: (batch, 512, 512, 9) one-hot encoded

    print(f"Image shape: {img.shape}")
    print(f"Boundary one-hot shape: {hot_boundary.shape}")
    print(f"Room one-hot shape: {hot_room.shape}")
    break

# Convert model output back to class indices
logits = tf.random.uniform([1, 512, 512, 9])  # Simulated room logits
class_image = convert_one_hot_to_image(logits)  # (1, 512, 512, 1) with class indices
```

--------------------------------

### Resize and convert logits

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Resizes logits to original shape and converts one-hot encoding to images.

```python
logits_r = tf.image.resize(logits_r,shp[:2])
logits_cw = tf.image.resize(logits_cw,shp[:2])
r = convert_one_hot_to_image(logits_r)[0].numpy()
cw = convert_one_hot_to_image(logits_cw)[0].numpy()
plt.subplot(1,2,1)
plt.imshow(r.squeeze()); plt.xticks([]); plt.yticks([]);
plt.subplot(1,2,2)
plt.imshow(cw.squeeze()); plt.xticks([]); plt.yticks([]);
```

--------------------------------

### Colorize post-processed results

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/deepfloorplan.ipynb

Applies color mapping to the post-processed results.

```python
newr_color,newcw_color = colorize(newr.squeeze(),newcw.squeeze())
plt.subplot(1,2,1)
plt.imshow(newr_color); plt.xticks([]); plt.yticks([]);
plt.subplot(1,2,2)
plt.imshow(newcw_color); plt.xticks([]); plt.yticks([]);
```

--------------------------------

### Prune Docker Build Cache

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/MacOS-setup

Remove unused build cache from Docker to free up disk space.

```bash
docker builder prune
```

--------------------------------

### Rebase target branch

Source: https://github.com/zcemycl/tf2deepfloorplan/wiki/Hate-my-git-practice

Update the current branch with changes from the development branch and force push the result.

```bash
git rebase origin/development
git push --force # if you are confident... ignore x pulls and y pushes.
```

--------------------------------

### Functional Model API

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Provides a functional Keras API version of the model (`deepfloorplanFunc`) supporting various backbone architectures like VGG16, MobileNetV1, MobileNetV2, and ResNet50.

```APIDOC
## Initialize Functional Model

### Description
Initializes the `deepfloorplanFunc` with a specified configuration and backbone.

### Method
Instantiation

### Parameters
#### Configuration (`config` Namespace)
- **feature_channels** (list of int) - Channels for feature maps.
- **backbone** (string) - Backbone architecture ('vgg16', 'mobilenetv1', 'mobilenetv2', 'resnet50').
- **feature_names** (list of string) - Names of features to extract from the backbone.

### Request Example
```python
import tensorflow as tf
from argparse import Namespace
from dfp.net_func import deepfloorplanFunc

# Example for VGG16 backbone
config_vgg = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='vgg16',
    feature_names=['block1_pool', 'block2_pool', 'block3_pool', 'block4_pool', 'block5_pool']
)
model_vgg = deepfloorplanFunc(config=config_vgg)

# Example for MobileNetV2 backbone
config_mobilenetv2 = Namespace(
    feature_channels=[256, 128, 64, 32],
    backbone='mobilenetv2',
    feature_names=['block_1_expand_relu', 'block_3_expand_relu', 'block_6_expand_relu', 'block_13_expand_relu', 'out_relu']
)
model_mobilenetv2 = deepfloorplanFunc(config=config_mobilenetv2)
```

### Response
#### Success Response
- A functional Keras model instance ready for inference.

#### Inference Output
- **logits_room** (tensor) - Logits for room type prediction.
- **logits_boundary** (tensor) - Logits for boundary prediction.
```

--------------------------------

### Convert Keras Model to TFLite

Source: https://context7.com/zcemycl/tf2deepfloorplan/llms.txt

Convert trained Keras models to TensorFlow Lite format for efficient deployment on mobile and edge devices. Supports post-training quantization and weight pruning for model compression. Models can be loaded from SavedModel protobuf files or checkpoint logs.

```bash
python -m dfp.convert2tflite --modeldir=model/store \
    --tflitedir=model/store/model.tflite --loadmethod=pb
```

```bash
python -m dfp.convert2tflite --modeldir=model/store \
    --tflitedir=model/store/model_quantized.tflite \
    --loadmethod=pb --quantize
```

```bash
python -m dfp.convert2tflite --modeldir=log/store/G \
    --tflitedir=model/model.tflite --loadmethod=log \
    --tfmodel=func --backbone=mobilenetv1 \
    --feature-names conv_pw_1_relu conv_pw_3_relu conv_pw_5_relu conv_pw_7_relu conv_pw_13_relu
```

```bash
python -m dfp.convert2tflite --modeldir=model/store \
    --compress-mode=prune --tfmodel=func --loadmethod=pb
```

--------------------------------

### Clean Up Local Branches

Source: https://github.com/zcemycl/tf2deepfloorplan/blob/main/README.md

After merging pull requests, this command sequence updates the local main branch, prunes remote-tracking branches that no longer exist on the remote, and deletes the local feature branch.

```bash
git checkout main
git pull
git remote prune origin
git branch -d xx-features
```
Tokens:
Raw