### Run AnyText2 Demo

Source: https://github.com/tyxsspa/anytext2/blob/main/README.md

This command initiates the AnyText2 demo, providing a user interface for experimentation. It requires an advanced GPU with at least 8GB of memory. The demo includes usage instructions and examples, and its parameters are consistent with the original AnyText project.

```bash
python demo.py
```

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

### Start AnyText2 Training

Source: https://github.com/tyxsspa/anytext2/blob/main/README.md

This command initiates the training process for AnyText2. The training dataset, AnyWord-3M, has been updated with annotation files for long captions and text color labels. Detailed training configurations are consistent with the AnyText documentation.

```bash
python train.py
```

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

### Clone Repository and Setup Environment

Source: https://github.com/tyxsspa/anytext2/blob/main/README.md

This bash script outlines the steps to clone the AnyText2 repository from GitHub, move the downloaded checkpoint into the correct directory, and create/activate a new conda environment using the provided `environment.yaml` file. This is essential for setting up the project locally.

```bash
git clone https://github.com/tyxsspa/AnyText2.git
cd AnyText2 && mkdir -p models  &&  sleep 1 && mv your_path_to_model_dir/* models
conda env create -f environment.yaml
conda activate anytext2
```

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

### Download Checkpoint with ModelScope

Source: https://github.com/tyxsspa/anytext2/blob/main/README.md

This snippet demonstrates how to download the AnyText2 checkpoint using the `modelscope` library. Ensure `modelscope` is installed before running this code. It specifies the model ID and the local directory to save the downloaded files.

```python
from modelscope import snapshot_download
your_path_to_model_dir = snapshot_download('iic/cv_anytext2')
```

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

### Initialize and Run AnyText2 for Text Generation (Python)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Demonstrates initializing the AnyText2Model for text generation, preparing input data including image and text prompts, and running the inference pipeline. It also shows how to save the generated images. Requires the ms_wrapper library and OpenCV.

```python
from ms_wrapper import AnyText2Model
import numpy as np
import cv2

# Initialize the model
inference = AnyText2Model(
    model_dir='./models',
    use_fp16=True,              # Use FP16 for faster inference (requires ~8GB VRAM)
    use_translator=True,        # Enable Chinese-to-English translation
    font_path='font/Arial_Unicode.ttf',
    model_path='models/anytext_v2.0.ckpt'
).cuda(0)

# Prepare input for text generation
input_data = {
    "img_prompt": "A coffee cup on a wooden table with cream art text",
    "text_prompt": 'The text says "Hello" and "World"',  # Quoted strings define the text
    "seed": 12345,
    "draw_pos": pos_image,     # numpy array: white text regions on black background
    "ori_image": None          # None for generation, image array for editing
}

# Generation parameters
params = {
    "mode": "gen",             # "gen" for generation, "edit" for editing
    "sort_priority": "↕",      # "↕" top-down, "↔" left-right sorting
    "show_debug": True,
    "revise_pos": False,
    "image_count": 4,
    "ddim_steps": 20,
    "image_width": 512,
    "image_height": 512,
    "strength": 1.0,
    "attnx_scale": 1.0,
    "font_hollow": True,       # Use hollow font rendering
    "cfg_scale": 7.5,
    "eta": 0.0,
    "a_prompt": "best quality, extremely detailed, clear text",
    "n_prompt": "low quality, blurry text, watermark",
    "glyline_font_path": ['font/Arial_Unicode.ttf', 'font/Arial_Unicode.ttf'],
    "text_colors": "255,0,0 0,255,0"  # RGB colors per text line
}

# Run inference
results, code, warning, debug_info = inference(input_data, **params)
# results: list of generated images as numpy arrays
# code: 0=success, 1=warning, -1=error
# warning: warning/error message string
# debug_info: HTML debug information

# Save results
for idx, img in enumerate(results):
    cv2.imwrite(f'output_{idx}.jpg', img[..., ::-1])

```

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

### Run AnyText2 Gradio Demo Interface (Bash)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Command to launch the Gradio web interface for AnyText2. This provides an interactive way to perform text generation and editing with features like font selection, color picking, and position drawing. Requires the demo.py script and a model checkpoint.

```bash
# Run the demo server
python demo.py --model_path models/anytext_v2.0.ckpt

```

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

### Run AnyText2 Demo with Optional Arguments

Source: https://context7.com/tyxsspa/anytext2/llms.txt

This command demonstrates how to run the AnyText2 demo script with various optional arguments. These arguments control precision, translator usage, and model/font paths, allowing for customization of the demo's behavior and resource consumption.

```bash
python demo.py \
    --use_fp32           # Use FP32 precision (slower, more stable) \
    --no_translator      # Disable Chinese-to-English translator (saves ~4GB VRAM) \
    --font_path font/Arial_Unicode.ttf \
    --model_path models/anytext_v2.0.ckpt
```

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

### Prepare AnyText2 Checkpoint by Merging Weights

Source: https://context7.com/tyxsspa/anytext2/llms.txt

This bash command prepares the AnyText2 checkpoint by merging Stable Diffusion 1.5 weights with ControlNet and OCR model components. The `tool_add_anytext.py` script handles the creation of ControlNet weights, addition of OCR model weights, and initialization of AttnX layers.

```bash
# Prepare checkpoint from SD 1.5
python tool_add_anytext.py /path/to/sd-v1-5-pruned.ckpt ./models/anytext2_sd15_scratch.ckpt

# The script automatically:
# 1. Creates ControlNet weights from SD UNet
# 2. Adds OCR model weights for text recognition
# 3. Initializes AttnX layers for attention modification
```

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

### Internal Logic of Checkpoint Preparation Tool

Source: https://context7.com/tyxsspa/anytext2/llms.txt

This Python script details the internal workings of the checkpoint preparation tool. It loads a base model, merges weights from a pretrained Stable Diffusion checkpoint, and incorporates OCR model weights. New layers are initialized, and the resulting merged checkpoint is saved.

```python
# tool_add_anytext.py internals
from cldm.model import create_model
import torch

# Configuration
add_ocr = True           # Merge OCR recognition model
add_style_ocr = True     # Add style-aware OCR for font mimicking
ocr_path = './ocr_weights/ppv3_rec.pth'

model = create_model('./models_yaml/anytext2_sd15.yaml')
pretrained = torch.load('sd-v1-5-pruned.ckpt')['state_dict']
scratch_dict = model.state_dict()

# Copy matching weights, initialize new layers
for k in scratch_dict.keys():
    if k.startswith('control_'):
        copy_k = 'model.diffusion_' + k[8:]  # Map control to diffusion
    elif 'attn1x' in k:
        copy_k = k.replace('attn1x', 'attn1')  # Init AttnX from Attn
    else:
        copy_k = k

    if copy_k in pretrained:
        scratch_dict[k] = pretrained[copy_k].clone()

torch.save(scratch_dict, './models/anytext2_sd15_scratch.ckpt')
```

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

### Train AnyText2 Model with PyTorch Lightning

Source: https://context7.com/tyxsspa/anytext2/llms.txt

This Python script configures and initiates the training pipeline for AnyText2 using PyTorch Lightning. It specifies model paths, training parameters, dataset configuration, and utilizes multi-GPU training with DDP support. The dataset format is detailed, including image paths, captions, and annotations for text editing.

```python
# train.py configuration
import pytorch_lightning as pl
from torch.utils.data import DataLoader
from t3_dataset import T3DataSet
from cldm.logger import ImageLogger
from cldm.model import create_model, load_state_dict
from pytorch_lightning.callbacks import ModelCheckpoint

# Training configuration
config = {
    'resume_path': './models/anytext2_sd15_scratch.ckpt',
    'config_path': './models_yaml/anytext2_sd15.yaml',
    'batch_size': 3,
    'grad_accum': 2,
    'learning_rate': 2e-5,
    'max_epochs': 15,
    'mask_ratio': 0.5,        # Ratio for text editing training
    'font_hint_prob': 0.8,    # Probability of using font hints
    'color_prob': 1.0,        # Probability of using color hints
    'rand_font': True,        # Randomize fonts during training
}

# Dataset JSON format:
# {
#   "data_root": "/path/to/images",
#   "data_list": [
#     {
#       "img_name": "image.jpg",
#       "caption": "Description of the image with * placeholders",
#       "annotations": [
#         {
#           "polygon": [[x1,y1], [x2,y2], [x3,y3], [x4,y4]],
#           "text": "HELLO",
#           "language": "Latin",
#           "color": [255, 0, 0],
#           "valid": true
#         }
#       ]
#     }
#   ]
# }

# Create model and dataset
model = create_model('./models_yaml/anytext2_sd15.yaml').cpu()
model.load_state_dict(load_state_dict('./models/anytext2_sd15_scratch.ckpt', location='cpu'))
model.learning_rate = 2e-5

dataset = T3DataSet(
    json_path=['path/to/data.json'],
    max_lines=5,
    max_chars=20,
    glyph_scale=1,
    rand_font=True,
    font_hint_prob=0.8,
    color_prob=1.0
)

dataloader = DataLoader(dataset, batch_size=3, shuffle=True, num_workers=8)
trainer = pl.Trainer(gpus=-1, precision=32, max_epochs=15, strategy='ddp')
trainer.fit(model, dataloader)
```

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

### Initialize T3Dataset and DataLoader (Python)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Sets up the custom PyTorch `T3DataSet` for loading training data, including image-text pairs, font hints, and color information. It configures various parameters like maximum lines/characters, masking probabilities, and rendering options. A `DataLoader` is then created for efficient batching during training.

```python
from t3_dataset import T3DataSet
from torch.utils.data import DataLoader

# Create dataset with full configuration
dataset = T3DataSet(
    json_path=['data/train_data.json'],      # Can be list of paths
    max_lines=5,                              # Max text lines per image
    max_chars=20,                             # Max characters per line
    place_holder='*',                         # Placeholder in captions
    font_path='./font/Arial_Unicode.ttf',
    mask_pos_prob=1.0,                        # Position mask probability
    mask_img_prob=0.5,                        # Image mask prob (editing mode)
    glyph_scale=1,                            # Glyph resolution scale
    percent=1.0,                              # Dataset percentage to use
    wm_thresh=1.0,                            # Watermark threshold
    render_glyph=True,
    trunc_cap=128,                            # Caption truncation length
    rand_font=True,                           # Random font selection
    lang_font_path='./font/lang_font_dict.npy',
    font_hint_prob=0.8,                       # Font hint probability
    color_prob=1.0,                           # Color hint probability
    font_hint_area=[0.7, 1.0],               # Reserved area range
    font_hint_randaug=True,                   # Random augmentation
    img_wh=512                                # Image size
)

# DataLoader for training
dataloader = DataLoader(
    dataset,
    batch_size=6,
    shuffle=True,
    num_workers=8,
    persistent_workers=True
)

# Dataset item structure:
# {
#   'img': ndarray (512, 512, 3),           # Target image [-1, 1]
#   'img_caption': str,                      # Image description
#   'text_caption': str,                     # Text prompt with placeholders
#   'glyphs': list[ndarray],                 # Positioned glyph images
#   'gly_line': list[ndarray],               # Line glyph images
#   'positions': list[ndarray],              # Position masks
#   'hint': ndarray,                         # Combined position hint
#   'font_hint': ndarray,                    # Font style hint
#   'masked_img': ndarray,                   # Masked image for editing
#   'color': list[ndarray],                  # RGB colors per line
#   'n_lines': int                           # Number of text lines
# }
```

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

### Evaluate AnyText2 Model on Benchmark Datasets

Source: https://context7.com/tyxsspa/anytext2/llms.txt

This bash command executes the single-GPU evaluation script for AnyText2. It specifies the input JSON containing test data, an output directory for generated images, the path to the model checkpoint, and the configuration YAML file.

```bash
# Run evaluation
python eval/anytext2_singleGPU.py \
    --input_json /path/to/test_data.json \
    --output_dir /path/to/generated_images \
    --ckpt_path ./models/anytext_v2.0.ckpt \
    --config_yaml ./models_yaml/anytext2_sd15.yaml
```

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

### AnyText2 Single-GPU Evaluation Script Usage

Source: https://context7.com/tyxsspa/anytext2/llms.txt

This Python script outlines the core components for evaluating the AnyText2 model on a single GPU. It includes loading the model, initializing the DDIM sampler, defining evaluation parameters such as sampling steps and CFG scale, and processing test data to generate images.

```python
# eval/anytext2_singleGPU.py usage
from cldm.model import create_model, load_state_dict
from cldm.ddim_hacked import DDIMSampler
from t3_dataset import draw_glyph, draw_glyph2
from PIL import ImageFont
import numpy as np

# Load model
model = create_model('./models_yaml/anytext2_sd15.yaml', use_fp16=True).cuda().eval()
model = model.half()
model.load_state_dict(load_state_dict('./models/anytext_v2.0.ckpt', location='cuda'))
ddim_sampler = DDIMSampler(model)

# Evaluation parameters
params = {
    'num_samples': 4,
    'image_resolution': 512,
    'ddim_steps': 20,
    'scale': 7.5,           # CFG scale
    'seed': 100,
    'eta': 0.0,
    'a_prompt': 'best quality, extremely detailed',
    'n_prompt': 'low quality, watermark, blurry'
}

# Process each test item and save generated images
# Results saved as {img_name}_0.jpg, {img_name}_1.jpg, etc.
```

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

### Perform Text Editing in an Image with AnyText2 (Python)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Illustrates how to use AnyText2 for editing existing text in an image. This involves loading an original image, creating a position mask for the editable area, and providing new text prompts. The system preserves the surrounding context while modifying the specified text regions. Requires OpenCV and ms_wrapper.

```python
import cv2
import numpy as np
from ms_wrapper import AnyText2Model

inference = AnyText2Model(model_dir='./models', use_fp16=True).cuda(0)

# Load original imageori_image = cv2.imread('original_sign.jpg')[..., ::-1]  # Convert BGR to RGB

# Create position mask (white regions indicate where to edit)
# Can be created programmatically or from a drawing interface
edit_mask = np.zeros((512, 512, 3), dtype=np.uint8)
cv2.rectangle(edit_mask, (100, 200), (400, 280), (255, 255, 255), -1)

input_data = {
    "img_prompt": "A wooden sign with carved text",
    "text_prompt": '"NEW TEXT"',  # New text to render
    "seed": 42,
    "draw_pos": 255 - edit_mask,  # Invert: white pos on black bg
    "ori_image": ori_image
}

params = {
    "mode": "edit",
    "image_count": 4,
    "ddim_steps": 20,
    "image_width": ori_image.shape[1],
    "image_height": ori_image.shape[0],
    "strength": 1.0,
    "cfg_scale": 7.5
}

results, code, warning, debug = inference(input_data, **params)
cv2.imwrite('edited_result.jpg', results[0][..., ::-1])

```

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

### Ensure 3 Channels (RGB) for Image (Python)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Converts an input image to a 3-channel RGB format. If the image is grayscale, it replicates the channel. If it has an alpha channel (RGBA), it strips the alpha channel.

```python
from util import check_channels
import numpy as np

# check_channels: Ensure image has 3 channels (RGB)
gray_img = np.zeros((512, 512), dtype=np.uint8)
rgb_img = check_channels(gray_img)  # Converts to (512, 512, 3)

rgba_img = np.zeros((512, 512, 4), dtype=np.uint8)
rgb_img = check_channels(rgba_img)  # Strips alpha channel
```

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

### Configure AnyText2 Model Parameters (YAML)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Defines the configuration for the AnyText2 Stable Diffusion 1.5 model using YAML. It specifies parameters for the ControlLDM, EmbeddingManager, ControlNet, and ControlledUnetModel, including channels, resolutions, and dimensions.

```yaml
model:
  target: cldm.cldm.ControlLDM
  params:
    linear_start: 0.00085
    linear_end: 0.0120
    timesteps: 1000
    image_size: 64
    channels: 4
    cond_stage_trainable: true
    scale_factor: 0.18215
    use_vae_upsample: true

    embedding_manager_config:
      target: cldm.embedding_manager.EmbeddingManager
      params:
        valid: true
        emb_type: ocr
        glyph_channels: 1
        position_channels: 1
        add_pos: true
        add_style_ocr: true
        style_ocr_trainable: true
        add_color: true

    control_stage_config:
      target: cldm.cldm.ControlNet
      params:
        in_channels: 4
        model_channels: 320
        glyph_channels: 1
        position_channels: 1
        attention_resolutions: [4, 2, 1]
        num_res_blocks: 2
        channel_mult: [1, 2, 4, 4]
        context_dim: 768
        fast_control: True

    unet_config:
      target: cldm.cldm.ControlledUnetModel
      params:
        in_channels: 4
        out_channels: 4
        model_channels: 320
        attention_resolutions: [4, 2, 1]
        num_res_blocks: 2
        channel_mult: [1, 2, 4, 4]
        context_dim: 768
        mid_attnx: True
        output_attnx: True
        output_attnx_level: [2, 1]
```

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

### Save Images with Timestamps (Python)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Saves a list of images to a specified folder with a timestamp and an optional batch ID. The function generates a unique filename including the date, time, batch ID, and an image index.

```python
from util import save_images
import numpy as np

# save_images: Save list of images with timestamps
img_list = [np.zeros((512, 512, 3), dtype=np.uint8)]
save_paths = save_images(img_list, folder='SaveImages', id='batch1')
# Saves to: SaveImages/2024-01-15/12_30_45_batch1_1.jpg
```

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

### Resize Image Maintaining Aspect Ratio (Python)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Resizes an image while maintaining its aspect ratio, ensuring that both dimensions are multiples of 64. This is useful for models that require specific input sizes.

```python
from util import resize_image
import numpy as np

# resize_image: Resize maintaining aspect ratio, ensure multiple of 64
large_img = np.zeros((1920, 1080, 3), dtype=np.uint8)
resized = resize_image(large_img, max_length=1024)
# Result shape: (576, 1024, 3) - height adjusted to multiple of 64
```

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

### Draw Text Glyphs with T3Dataset Functions (Python)

Source: https://context7.com/tyxsspa/anytext2/llms.txt

Renders text glyphs using `draw_glyph` for single-line images and `draw_glyph2` for positioned, colored glyphs within a specified polygon. These functions are crucial for generating conditioning signals for diffusion models. `draw_glyph` returns a NumPy array for text embedding, while `draw_glyph2` returns a full image array with color.

```python
from t3_dataset import draw_glyph, draw_glyph2
from PIL import ImageFont
import numpy as np

font = ImageFont.truetype('./font/Arial_Unicode.ttf', size=60)

# draw_glyph: Creates a single-line glyph image (512x80)
# Used for text embedding encoding
glyph_line = draw_glyph(font, "Hello World")
# Returns: numpy array shape (80, 512, 1), values 0-1

# draw_glyph2: Creates positioned glyph with color in full image
# Used for visual conditioning
polygon = np.array([[100, 100], [400, 100], [400, 150], [100, 150]])
color = np.array([255, 128, 0])  # RGB orange

glyph_positioned = draw_glyph2(
    font=font,                    # PIL ImageFont or path string
    text="SAMPLE",
    polygon=polygon,              # 4-point bounding polygon
    color=color,                  # RGB color array
    vertAng=10,                   # Angle threshold for vertical text
    scale=1,                      # Glyph scale factor
    width=512,
    height=512,
    add_space=True               # Add spacing between characters
)
# Returns: numpy array shape (512, 512, 3), values 0-1
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.