Respan Dataset Explorer

im,using,pytorch,use,something,like,savedmodel

In PyTorch, if you've trained a model on a GPU and want to save it for CPU inference later, you can save the model's state dictionary and then load it into a model instance on the CPU. Here’s how you can do this:

### Saving a Model Trained on GPU

1. **Save the Model's State Dict**: This step involves saving the learnable parameters of the model (i.e., its weights and biases) to a file.

```python
import torch

# Assume `model` is your trained model
# Save the model's state_dict (weights and biases)
torch.save(model.state_dict(), 'model_weights.pth')
```

### Loading for CPU Inference

1. **Load Model State Dict**: When loading the model for inference on a CPU, you need to have the model class or structure defined beforehand.

```python
import torch
import torch.nn as nn

# Define the model architecture (same as when it was trained)
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=5)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2, 2)
        # ... add more layers as needed

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        # ... define the forward pass as per your model architecture
        return x

# Instantiate the model
model = MyModel()

# Load the state dictionary onto the CPU
model.load_state_dict(torch.load('model_weights.pth', map_location=torch.device('cpu')))

# Set the model to evaluation mode
model.eval()

# Prepare an input tensor for CPU
input_tensor = torch.randn(1, 3, 32, 32)

# Perform inference
output = model(input_tensor)

print(output)
```

### Key Points:

- **Model Definition**: You must have the same model architecture defined when loading the weights for inference.

- **`map_location` Parameter**: Using `map_location=torch.device('cpu')` ensures that model weights are loaded to the CPU, even if they were originally saved from a GPU.

- **Set to Evaluation Mode**: Calling `model.eval()` sets the model to evaluation mode, which is crucial, especially if your network uses layers like dropout or batch normalization that behave differently during training and inference.

By following these steps, you can easily train a model on a GPU and then perform inference on a CPU, making your workflow flexible and adaptable to different environments.

i,have,import argparse
import typing as tp
from collections import defaultdict
from functools import wraps
from pathlib import Path

import numpy as np
import torch
import torchvision.transforms.functional as F
from PIL import Image
from torchvision.io import read_image, ImageReadMode

from models.Alignment import Alignment
from models.Blending import Blending
from models.Embedding import Embedding
from models.Net import Net
from utils.image_utils import equal_replacer
from utils.seed import seed_setter
from utils.shape_predictor import align_face
from utils.time import bench_session

TImage = tp.TypeVar('TImage', torch.Tensor, Image.Image, np.ndarray)
TPath = tp.TypeVar('TPath', Path, str)
TReturn = tp.TypeVar('TReturn', torch.Tensor, tuple[torch.Tensor, ...])


class HairFast:
    """
    HairFast implementation with hairstyle transfer interface
    """

    def __init__(self, args):
        self.args = args
        self.net = Net(self.args)
        self.embed = Embedding(args, net=self.net)
        self.align = Alignment(args, self.embed.get_e4e_embed, net=self.net)
        self.blend = Blending(args, net=self.net)

    @seed_setter
    @bench_session
    def __swap_from_tensors(self, face: torch.Tensor, shape: torch.Tensor, color: torch.Tensor,
                            **kwargs) -> torch.Tensor:
        images_to_name = defaultdict(list)
        for image, name in zip((face, shape, color), ('face', 'shape', 'color')):
            images_to_name[image].append(name)

        # Embedding stage
        name_to_embed = self.embed.embedding_images(images_to_name, **kwargs)

        # Alignment stage
        align_shape = self.align.align_images('face', 'shape', name_to_embed, **kwargs)

        # Shape Module stage for blending
        if shape is not color:
            align_color = self.align.shape_module('face', 'color', name_to_embed, **kwargs)
        else:
            align_color = align_shape

        # Blending and Post Process stage
        final_image = self.blend.blend_images(align_shape, align_color, name_to_embed, **kwargs)
        return final_image

    def swap(self, face_img: TImage | TPath, shape_img: TImage | TPath, color_img: TImage | TPath,
             benchmark=False, align=False, seed=None, exp_name=None, **kwargs) -> TReturn:
        """
        Run HairFast on the input images to transfer hair shape and color to the desired images.
        :param face_img:  face image in Tensor, PIL Image, array or file path format
        :param shape_img: shape image in Tensor, PIL Image, array or file path format
        :param color_img: color image in Tensor, PIL Image, array or file path format
        :param benchmark: starts counting the speed of the session
        :param align:     for arbitrary photos crops images to faces
        :param seed:      fixes seed for reproducibility, default 3407
        :param exp_name:  used as a folder name when 'save_all' model is enabled
        :return:          returns the final image as a Tensor
        """
        images: list[torch.Tensor] = []
        path_to_images: dict[TPath, torch.Tensor] = {}

        for img in (face_img, shape_img, color_img):
            if isinstance(img, (torch.Tensor, Image.Image, np.ndarray)):
                if not isinstance(img, torch.Tensor):
                    img = F.to_tensor(img)
            elif isinstance(img, (Path, str)):
                path_img = img
                if path_img not in path_to_images:
                    path_to_images[path_img] = read_image(str(path_img), mode=ImageReadMode.RGB)
                img = path_to_images[path_img]
            else:
                raise TypeError(f'Unsupported image format {type(img)}')

            images.append(img)

        if align:
            images = align_face(images)
        images = equal_replacer(images)

        final_image = self.__swap_from_tensors(*images, seed=seed, benchmark=benchmark, exp_name=exp_name, **kwargs)

        if align:
            return final_image, *images
        return final_image

    @wraps(swap)
    def __call__(self, *args, **kwargs):
        return self.swap(*args, **kwargs)


def get_parser():
    parser = argparse.ArgumentParser(description='HairFast')

    # I/O arguments
    parser.add_argument('--save_all_dir', type=Path, default=Path('output'),
                        help='the directory to save the latent codes and inversion images')

    # StyleGAN2 setting
    parser.add_argument('--size', type=int, default=1024)
    parser.add_argument('--ckpt', type=str, default="pretrained_models/StyleGAN/ffhq.pt")
    parser.add_argument('--channel_multiplier', type=int, default=2)
    parser.add_argument('--latent', type=int, default=512)
    parser.add_argument('--n_mlp', type=int, default=8)

    # Arguments
    parser.add_argument('--device', type=str, default='cuda')
    parser.add_argument('--batch_size', type=int, default=3, help='batch size for encoding images')
    parser.add_argument('--save_all', action='store_true', help='save and print mode information')

    # HairFast setting
    parser.add_argument('--mixing', type=float, default=0.95, help='hair blending in alignment')
    parser.add_argument('--smooth', type=int, default=5, help='dilation and erosion parameter')
    parser.add_argument('--rotate_checkpoint', type=str, default='pretrained_models/Rotate/rotate_best.pth')
    parser.add_argument('--blending_checkpoint', type=str, default='pretrained_models/Blending/checkpoint.pth')
    parser.add_argument('--pp_checkpoint', type=str, default='pretrained_models/PostProcess/pp_model.pth')
    return parser


if __name__ == '__main__':
    model_args = get_parser()
    args = model_args.parse_args()
    hair_fast = HairFast(args)
import torch
import torch.nn.functional as F
import torchvision.transforms as T
from torch import nn

from models.CtrlHair.shape_branch.config import cfg as cfg_mask
from models.CtrlHair.shape_branch.solver import get_hair_face_code, get_new_shape, Solver as SolverMask
from models.Encoders import RotateModel
from models.Net import Net, get_segmentation
from models.sean_codes.models.pix2pix_model import Pix2PixModel, SEAN_OPT, encode_sean, decode_sean
from utils.image_utils import DilateErosion
from utils.save_utils import save_vis_mask, save_gen_image, save_latents


class Alignment(nn.Module):
    """
    Module for transferring the desired hair shape
    """

    def __init__(self, opts, latent_encoder=None, net=None):
        super().__init__()
        self.opts = opts
        self.latent_encoder = latent_encoder
        if not net:
            self.net = Net(self.opts)
        else:
            self.net = net

        self.sean_model = Pix2PixModel(SEAN_OPT)
        self.sean_model.eval()

        solver_mask = SolverMask(cfg_mask, device=self.opts.device, local_rank=-1, training=False)
        self.mask_generator = solver_mask.gen
        self.mask_generator.load_state_dict(torch.load('pretrained_models/ShapeAdaptor/mask_generator.pth'))

        self.rotate_model = RotateModel()
        self.rotate_model.load_state_dict(torch.load(self.opts.rotate_checkpoint)['model_state_dict'])
        self.rotate_model.to(self.opts.device).eval()

        self.dilate_erosion = DilateErosion(dilate_erosion=self.opts.smooth, device=self.opts.device)
        self.to_bisenet = T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))

    @torch.inference_mode()
    def shape_module(self, im_name1: str, im_name2: str, name_to_embed, only_target=True, **kwargs):
        device = self.opts.device

        # load images
        img1_in = name_to_embed[im_name1]['image_256']
        img2_in = name_to_embed[im_name2]['image_256']

        # load latents
        latent_W_1 = name_to_embed[im_name1]["W"]
        latent_W_2 = name_to_embed[im_name2]["W"]

        # load masks
        inp_mask1 = name_to_embed[im_name1]['mask']
        inp_mask2 = name_to_embed[im_name2]['mask']

        # Rotate stage
        if img1_in is not img2_in:
            rotate_to = self.rotate_model(latent_W_2[:, :6], latent_W_1[:, :6])
            rotate_to = torch.cat((rotate_to, latent_W_2[:, 6:]), dim=1)
            I_rot, _ = self.net.generator([rotate_to], input_is_latent=True, return_latents=False)

            I_rot_to_seg = ((I_rot + 1) / 2).clip(0, 1)
            I_rot_to_seg = self.to_bisenet(I_rot_to_seg)
            rot_mask = get_segmentation(I_rot_to_seg)
        else:
            I_rot = None
            rot_mask = inp_mask2

        # Shape Adaptor
        if img1_in is not img2_in:
            face_1, hair_1 = get_hair_face_code(self.mask_generator, inp_mask1[0, 0, ...])
            face_2, hair_2 = get_hair_face_code(self.mask_generator, rot_mask[0, 0, ...])

            target_mask = get_new_shape(self.mask_generator, face_1, hair_2)[None, None]
        else:
            target_mask = inp_mask1

        # Hair mask
        hair_mask_target = torch.where(target_mask == 13, torch.ones_like(target_mask, device=device),
                                       torch.zeros_like(target_mask, device=device))

        if self.opts.save_all:
            exp_name = exp_name if (exp_name := kwargs.get('exp_name')) is not None else ""
            output_dir = self.opts.save_all_dir / exp_name
            if I_rot is not None:
                save_gen_image(output_dir, 'Shape', f'{im_name2}_rotate_to_{im_name1}.png', I_rot)
            save_vis_mask(output_dir, 'Shape', f'mask_{im_name1}.png', inp_mask1)
            save_vis_mask(output_dir, 'Shape', f'mask_{im_name2}.png', inp_mask2)
            save_vis_mask(output_dir, 'Shape', f'mask_{im_name2}_rotate_to_{im_name1}.png', rot_mask)
            save_vis_mask(output_dir, 'Shape', f'mask_{im_name1}_{im_name2}_target.png', target_mask)

        if only_target:
            return {'HM_X': hair_mask_target}
        else:
            hair_mask1 = torch.where(inp_mask1 == 13, torch.ones_like(inp_mask1, device=device),
                                     torch.zeros_like(inp_mask1, device=device))
            hair_mask2 = torch.where(inp_mask2 == 13, torch.ones_like(inp_mask2, device=device),
                                     torch.zeros_like(inp_mask2, device=device))

            return inp_mask1, hair_mask1, inp_mask2, hair_mask2, target_mask, hair_mask_target

    @torch.inference_mode()
    def align_images(self, im_name1, im_name2, name_to_embed, **kwargs):
        # load images
        img1_in = name_to_embed[im_name1]['image_256']
        img2_in = name_to_embed[im_name2]['image_256']

        # load latents
        latent_S_1, latent_F_1 = name_to_embed[im_name1]["S"], name_to_embed[im_name1]["F"]
        latent_S_2, latent_F_2 = name_to_embed[im_name2]["S"], name_to_embed[im_name2]["F"]

        # Shape Module
        if img1_in is img2_in:
            hair_mask_target = self.shape_module(im_name1, im_name2, name_to_embed, only_target=True, **kwargs)['HM_X']
            return {'latent_F_align': latent_F_1, 'HM_X': hair_mask_target}

        inp_mask1, hair_mask1, inp_mask2, hair_mask2, target_mask, hair_mask_target = (
            self.shape_module(im_name1, im_name2, name_to_embed, only_target=False, **kwargs)
        )

        images = torch.cat([img1_in, img2_in], dim=0)
        labels = torch.cat([inp_mask1, inp_mask2], dim=0)

        # SEAN for inpaint
        img1_code, img2_code = encode_sean(self.sean_model, images, labels)

        gen1_sean = decode_sean(self.sean_model, img1_code.unsqueeze(0), target_mask)
        gen2_sean = decode_sean(self.sean_model, img2_code.unsqueeze(0), target_mask)

        # Encoding result in F from E4E
        enc_imgs = self.latent_encoder([gen1_sean, gen2_sean])
        intermediate_align, latent_inter = enc_imgs["F"][0].unsqueeze(0), enc_imgs["W"][0].unsqueeze(0)
        latent_F_out_new, latent_out = enc_imgs["F"][1].unsqueeze(0), enc_imgs["W"][1].unsqueeze(0)

        # Alignment of F space
        masks = [
            1 - (1 - hair_mask1) * (1 - hair_mask_target),
            hair_mask_target,
            hair_mask2 * hair_mask_target
        ]
        masks = torch.cat(masks, dim=0)
        # masks = T.functional.resize(masks, (1024, 1024), interpolation=T.InterpolationMode.NEAREST)

        dilate, erosion = self.dilate_erosion.mask(masks)
        free_mask = [
            dilate[0],
            erosion[1],
            erosion[2]
        ]
        free_mask = torch.stack(free_mask, dim=0)
        free_mask_down_32 = F.interpolate(free_mask.float(), size=(32, 32), mode='bicubic')
        interpolation_low = 1 - free_mask_down_32

        latent_F_align = intermediate_align + interpolation_low[0] * (latent_F_1 - intermediate_align)
        latent_F_align = latent_F_out_new + interpolation_low[1] * (latent_F_align - latent_F_out_new)
        latent_F_align = latent_F_2 + interpolation_low[2] * (latent_F_align - latent_F_2)

        if self.opts.save_all:
            exp_name = exp_name if (exp_name := kwargs.get('exp_name')) is not None else ""
            output_dir = self.opts.save_all_dir / exp_name
            save_gen_image(output_dir, 'Align', f'{im_name1}_{im_name2}_SEAN.png', gen1_sean)
            save_gen_image(output_dir, 'Align', f'{im_name2}_{im_name1}_SEAN.png', gen2_sean)

            img1_e4e = self.net.generator([latent_inter], input_is_latent=True, return_latents=False, start_layer=4,
                                          end_layer=8, layer_in=intermediate_align)[0]
            img2_e4e = self.net.generator([latent_out], input_is_latent=True, return_latents=False, start_layer=4,
                                          end_layer=8, layer_in=latent_F_out_new)[0]

            save_gen_image(output_dir, 'Align', f'{im_name1}_{im_name2}_e4e.png', img1_e4e)
            save_gen_image(output_dir, 'Align', f'{im_name2}_{im_name1}_e4e.png', img2_e4e)

            gen_im, _ = self.net.generator([latent_S_1], input_is_latent=True, return_latents=False, start_layer=4,
                                           end_layer=8, layer_in=latent_F_align)

            save_gen_image(output_dir, 'Align', f'{im_name1}_{im_name2}_output.png', gen_im)
            save_latents(output_dir, 'Align', f'{im_name1}_{im_name2}_F.npz', latent_F_align=latent_F_align)

        return {'latent_F_align': latent_F_align, 'HM_X': hair_mask_target}
import torch
from torch import nn

from models.Encoders import ClipBlendingModel, PostProcessModel
from models.Net import Net
from utils.bicubic import BicubicDownSample
from utils.image_utils import DilateErosion
from utils.save_utils import save_gen_image, save_latents


class Blending(nn.Module):
    """
    Module for transferring the desired hair color and post processing
    """

    def __init__(self, opts, net=None):
        super().__init__()
        self.opts = opts
        if net is None:
            self.net = Net(self.opts)
        else:
            self.net = net

        blending_checkpoint = torch.load(self.opts.blending_checkpoint)
        self.blending_encoder = ClipBlendingModel(blending_checkpoint.get('clip', "ViT-B/32"))
        self.blending_encoder.load_state_dict(blending_checkpoint['model_state_dict'], strict=False)
        self.blending_encoder.to(self.opts.device).eval()

        self.post_process = PostProcessModel().to(self.opts.device).eval()
        self.post_process.load_state_dict(torch.load(self.opts.pp_checkpoint)['model_state_dict'])

        self.dilate_erosion = DilateErosion(dilate_erosion=self.opts.smooth, device=self.opts.device)
        self.downsample_256 = BicubicDownSample(factor=4)

    @torch.inference_mode()
    def blend_images(self, align_shape, align_color, name_to_embed, **kwargs):
        I_1 = name_to_embed['face']['image_norm_256']
        I_2 = name_to_embed['shape']['image_norm_256']
        I_3 = name_to_embed['color']['image_norm_256']

        mask_de = self.dilate_erosion.hair_from_mask(
            torch.cat([name_to_embed[x]['mask'] for x in ['face', 'color']], dim=0)
        )
        HM_1D, _ = mask_de[0][0].unsqueeze(0), mask_de[1][0].unsqueeze(0)
        HM_3D, HM_3E = mask_de[0][1].unsqueeze(0), mask_de[1][1].unsqueeze(0)

        latent_S_1, latent_F_align = name_to_embed['face']['S'], align_shape['latent_F_align']
        HM_X = align_color['HM_X']

        latent_S_3 = name_to_embed['color']["S"]

        HM_XD, _ = self.dilate_erosion.mask(HM_X)
        target_mask = (1 - HM_1D) * (1 - HM_3D) * (1 - HM_XD)

        # Blending
        if I_1 is not I_3 or I_1 is not I_2:
            S_blend_6_18 = self.blending_encoder(latent_S_1[:, 6:], latent_S_3[:, 6:], I_1 * target_mask, I_3 * HM_3E)
            S_blend = torch.cat((latent_S_1[:, :6], S_blend_6_18), dim=1)
        else:
            S_blend = latent_S_1

        I_blend, _ = self.net.generator([S_blend], input_is_latent=True, return_latents=False, start_layer=4,
                                        end_layer=8, layer_in=latent_F_align)
        I_blend_256 = self.downsample_256(I_blend)

        # Post Process
        S_final, F_final = self.post_process(I_1, I_blend_256)
        I_final, _ = self.net.generator([S_final], input_is_latent=True, return_latents=False,
                                         start_layer=5, end_layer=8, layer_in=F_final)

        if self.opts.save_all:
            exp_name = exp_name if (exp_name := kwargs.get('exp_name')) is not None else ""
            output_dir = self.opts.save_all_dir / exp_name
            save_gen_image(output_dir, 'Blending', 'blending.png', I_blend)
            save_latents(output_dir, 'Blending', 'blending.npz', S_blend=S_blend)

            save_gen_image(output_dir, 'Final', 'final.png', I_final)
            save_latents(output_dir, 'Final', 'final.npz', S_final=S_final, F_final=F_final)

        final_image = ((I_final[0] + 1) / 2).clip(0, 1)
        return final_image
from collections import defaultdict

import torch
import torch.nn.functional as F
import torchvision.transforms as T
from torch import nn
from torch.utils.data import DataLoader

from datasets.image_dataset import ImagesDataset, image_collate
from models.FeatureStyleEncoder import FSencoder
from models.Net import Net, get_segmentation
from models.encoder4editing.utils.model_utils import setup_model, get_latents
from utils.bicubic import BicubicDownSample
from utils.save_utils import save_gen_image, save_latents


class Embedding(nn.Module):
    """
    Module for image embedding
    """

    def __init__(self, opts, net=None):
        super().__init__()
        self.opts = opts
        if net is None:
            self.net = Net(self.opts)
        else:
            self.net = net

        self.encoder = FSencoder.get_trainer(self.opts.device)
        self.e4e, _ = setup_model('pretrained_models/encoder4editing/e4e_ffhq_encode.pt', self.opts.device)

        self.normalize = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
        self.to_bisenet = T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))

        self.downsample_512 = BicubicDownSample(factor=2)
        self.downsample_256 = BicubicDownSample(factor=4)

    def setup_dataloader(self, images: dict[torch.Tensor, list[str]] | list[torch.Tensor], batch_size=None):
        self.dataset = ImagesDataset(images)
        self.dataloader = DataLoader(self.dataset, collate_fn=image_collate, shuffle=False,
                                     batch_size=batch_size or self.opts.batch_size)

    @torch.inference_mode()
    def get_e4e_embed(self, images: list[torch.Tensor]) -> dict[str, torch.Tensor]:
        device = self.opts.device
        self.setup_dataloader(images, batch_size=len(images))

        for image, _ in self.dataloader:
            image = image.to(device)
            latent_W = get_latents(self.e4e, image)
            latent_F, _ = self.net.generator([latent_W], input_is_latent=True, return_latents=False,
                                             start_layer=0, end_layer=3)
            return {"F": latent_F, "W": latent_W}

    @torch.inference_mode()
    def embedding_images(self, images_to_name: dict[torch.Tensor, list[str]], **kwargs) -> dict[
        str, dict[str, torch.Tensor]]:
        device = self.opts.device
        self.setup_dataloader(images_to_name)

        name_to_embed = defaultdict(dict)
        for image, names in self.dataloader:
            image = image.to(device)

            im_512 = self.downsample_512(image)
            im_256 = self.downsample_256(image)
            im_256_norm = self.normalize(im_256)

            # E4E
            latent_W = get_latents(self.e4e, im_256_norm)

            # FS encoder
            output = self.encoder.test(img=self.normalize(image), return_latent=True)
            latent = output.pop()  # [bs, 512, 16, 16]
            latent_S = output.pop()  # [bs, 18, 512]

            latent_F, _ = self.net.generator([latent_S], input_is_latent=True, return_latents=False,
                                             start_layer=3, end_layer=3, layer_in=latent)  # [bs, 512, 32, 32]

            # BiSeNet
            masks = torch.cat([get_segmentation(image.unsqueeze(0)) for image in self.to_bisenet(im_512)])

            # Mixing if we change the color or shape
            if len(images_to_name) > 1:
                hair_mask = torch.where(masks == 13, torch.ones_like(masks, device=device),
                                        torch.zeros_like(masks, device=device))
                hair_mask = F.interpolate(hair_mask.float(), size=(32, 32), mode='bicubic')

                latent_F_from_W = self.net.generator([latent_W], input_is_latent=True, return_latents=False,
                                                     start_layer=0, end_layer=3)[0]
                latent_F = latent_F + self.opts.mixing * hair_mask * (latent_F_from_W - latent_F)

            for k, names in enumerate(names):
                for name in names:
                    name_to_embed[name]['W'] = latent_W[k].unsqueeze(0)
                    name_to_embed[name]['F'] = latent_F[k].unsqueeze(0)
                    name_to_embed[name]['S'] = latent_S[k].unsqueeze(0)
                    name_to_embed[name]['mask'] = masks[k].unsqueeze(0)
                    name_to_embed[name]['image_256'] = im_256[k].unsqueeze(0)
                    name_to_embed[name]['image_norm_256'] = im_256_norm[k].unsqueeze(0)

            if self.opts.save_all:
                gen_W_im, _ = self.net.generator([latent_W], input_is_latent=True, return_latents=False)
                gen_FS_im, _ = self.net.generator([latent_S], input_is_latent=True, return_latents=False,
                                                  start_layer=4, end_layer=8, layer_in=latent_F)

                exp_name = exp_name if (exp_name := kwargs.get('exp_name')) is not None else ""
                output_dir = self.opts.save_all_dir / exp_name
                for name, im_W, lat_W in zip(names, gen_W_im, latent_W):
                    save_gen_image(output_dir, 'W+', f'{name}.png', im_W)
                    save_latents(output_dir, 'W+', f'{name}.npz', latent_W=lat_W)

                for name, im_F, lat_S, lat_F in zip(names, gen_FS_im, latent_S, latent_F):
                    save_gen_image(output_dir, 'FS', f'{name}.png', im_F)
                    save_latents(output_dir, 'FS', f'{name}.npz', latent_S=lat_S, latent_F=lat_F)

        return name_to_embed
import argparse

import clip
import torch
import torch.nn as nn
from torch.nn import Linear, LayerNorm, LeakyReLU, Sequential
from torchvision import transforms as T

from models.Net import FeatureEncoderMult, IBasicBlock, conv1x1
from models.stylegan2.model import PixelNorm


class ModulationModule(nn.Module):
    def __init__(self, layernum, last=False, inp=512, middle=512):
        super().__init__()
        self.layernum = layernum
        self.last = last
        self.fc = Linear(512, 512)
        self.norm = LayerNorm([self.layernum, 512], elementwise_affine=False)
        self.gamma_function = Sequential(Linear(inp, middle), LayerNorm([middle]), LeakyReLU(), Linear(middle, 512))
        self.beta_function = Sequential(Linear(inp, middle), LayerNorm([middle]), LeakyReLU(), Linear(middle, 512))
        self.leakyrelu = LeakyReLU()

    def forward(self, x, embedding):
        x = self.fc(x)
        x = self.norm(x)
        gamma = self.gamma_function(embedding)
        beta = self.beta_function(embedding)
        out = x * (1 + gamma) + beta
        if not self.last:
            out = self.leakyrelu(out)
        return out


class FeatureiResnet(nn.Module):
    def __init__(self, blocks, inplanes=1024):
        super().__init__()

        self.res_blocks = {}

        for n, block in enumerate(blocks, start=1):
            planes, num_blocks = block

            for k in range(1, num_blocks + 1):
                downsample = None
                if inplanes != planes:
                    downsample = nn.Sequential(conv1x1(inplanes, planes, 1), nn.BatchNorm2d(planes, eps=1e-05, ), )

                self.res_blocks[f'res_block_{n}_{k}'] = IBasicBlock(inplanes, planes, 1, downsample, 1, 64, 1)
                inplanes = planes

        self.res_blocks = nn.ModuleDict(self.res_blocks)

    def forward(self, x):
        for module in self.res_blocks.values():
            x = module(x)
        return x


class RotateModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.pixelnorm = PixelNorm()
        self.modulation_module_list = nn.ModuleList([ModulationModule(6, i == 4) for i in range(5)])

    def forward(self, latent_from, latent_to):
        dt_latent = self.pixelnorm(latent_from)
        for modulation_module in self.modulation_module_list:
            dt_latent = modulation_module(dt_latent, latent_to)
        output = latent_from + 0.1 * dt_latent
        return output


class ClipBlendingModel(nn.Module):
    def __init__(self, clip_model="ViT-B/32"):
        super().__init__()
        self.pixelnorm = PixelNorm()
        self.clip_model, _ = clip.load(clip_model, device="cuda")
        self.transform = T.Compose(
            [T.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))])
        self.face_pool = torch.nn.AdaptiveAvgPool2d((224, 224))
        self.modulation_module_list = nn.ModuleList(
            [ModulationModule(12, i == 4, inp=512 * 3, middle=1024) for i in range(5)]
        )

        for param in self.clip_model.parameters():
            param.requires_grad = False

    def get_image_embed(self, image_tensor):
        resized_tensor = self.face_pool(image_tensor)
        renormed_tensor = self.transform(resized_tensor * 0.5 + 0.5)
        return self.clip_model.encode_image(renormed_tensor)

    def forward(self, latent_face, latent_color, target_face, hair_color):
        embed_face = self.get_image_embed(target_face).unsqueeze(1).expand(-1, 12, -1)
        embed_color = self.get_image_embed(hair_color).unsqueeze(1).expand(-1, 12, -1)
        latent_in = torch.cat((latent_color, embed_face, embed_color), dim=-1)

        dt_latent = self.pixelnorm(latent_face)
        for modulation_module in self.modulation_module_list:
            dt_latent = modulation_module(dt_latent, latent_in)
        output = latent_face + 0.1 * dt_latent
        return output


class PostProcessModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder_face = FeatureEncoderMult(fs_layers=[9], opts=argparse.Namespace(
            **{'arcface_model_path': "pretrained_models/ArcFace/backbone_ir50.pth"}))

        self.latent_avg = torch.load('pretrained_models/PostProcess/latent_avg.pt', map_location=torch.device('cuda'))
        self.to_feature = FeatureiResnet([[1024, 2], [768, 2], [512, 2]])

        self.to_latent_1 = nn.ModuleList([ModulationModule(18, i == 4) for i in range(5)])
        self.to_latent_2 = nn.ModuleList([ModulationModule(18, i == 4) for i in range(5)])
        self.pixelnorm = PixelNorm()

    def forward(self, source, target):
        s_face, [f_face] = self.encoder_face(source)
        s_hair, [f_hair] = self.encoder_face(target)

        dt_latent_face = self.pixelnorm(s_face)
        dt_latent_hair = self.pixelnorm(s_hair)

        for mod_module in self.to_latent_1:
            dt_latent_face = mod_module(dt_latent_face, s_hair)

        for mod_module in self.to_latent_2:
            dt_latent_hair = mod_module(dt_latent_hair, s_face)

        finall_s = self.latent_avg + 0.1 * (dt_latent_face + dt_latent_hair)

        cat_f = torch.cat((f_face, f_hair), dim=1)
        finall_f = self.to_feature(cat_f)

        return finall_s, finall_f


class ClipModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.clip_model, _ = clip.load("ViT-B/32", device="cuda")
        self.transform = T.Compose(
            [T.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))]
        )
        self.face_pool = torch.nn.AdaptiveAvgPool2d((224, 224))

        for param in self.clip_model.parameters():
            param.requires_grad = False

    def forward(self, image_tensor):
        if not image_tensor.is_cuda:
            image_tensor = image_tensor.to("cuda")
        if image_tensor.dtype == torch.uint8:
            image_tensor = image_tensor / 255

        resized_tensor = self.face_pool(image_tensor)
        renormed_tensor = self.transform(resized_tensor)
        return self.clip_model.encode_image(renormed_tensor)

do,to,cpu,on,every,part,needed,hereimport argparse
from pathlib import Path
from hair_swap import HairFast, get_parser

model_args = get_parser()
hair_fast = HairFast(model_args.parse_args([]))

To adapt the provided PyTorch code from GPU execution to CPU execution for inference, you need to ensure that both the model and the input data are loaded to the CPU. Here is a step-by-step guide and the necessary changes you need to make in your PyTorch code to achieve this:

### Load Model on CPU

When you load your model or any part of the model, make sure to specify the device as CPU. This includes all the `load_state_dict` and model instantiation points. Anywhere you see `.to(self.opts.device)`, replace it with `.to('cpu')` or use a variable that defaults to CPU.

### Example Steps

Here's a detailed example for preparing the `HairFast` and associated modules to run on CPU instead of GPU:

1. **Ensure All Models Are Loaded on CPU:**

Each part of your model should be explicitly set to work on the CPU.

```python
import argparse
import torch
from pathlib import Path

# Import the modules you have
from hair_swap import HairFast, get_parser  # assuming `hair_swap` contains your HairFast implementation

# Modify the argument parser to set device to CPU
def get_cpu_parser():
    parser = argparse.ArgumentParser(description='HairFast CPU inference')
    parser.add_argument('--device', type=str, default='cpu')  # Set the default device to CPU
    # Add other arguments as defined before
    parser.add_argument('--save_all_dir', type=Path, default=Path('output'),
                        help='the directory to save the latent codes and inversion images')
    # Add all other arguments as previously defined
    return parser

# Prepare parser and model
model_args = get_cpu_parser()
args = model_args.parse_args([])  # parse with default arguments if needed

# Instantiate HairFast with CPU arguments
hair_fast = HairFast(args)
```

2. **Adjust Model and State Loading to CPU:**

Ensure state_dict loading specifies CPU, especially for models previously trained on GPU:

```python
# When loading pre-trained model weights
self.rotate_model.load_state_dict(torch.load(self.opts.rotate_checkpoint, map_location='cpu')['model_state_dict'])
self.blending_encoder.load_state_dict(blending_checkpoint['model_state_dict'], strict=False)

# Repeat the pattern for all model components
```

3. **Update Model Components to CPU:**

Wherever you have model components being initialized or set up, ensure they default to the CPU:

```python
# Inside each relevant model component initialization
self.net = Net(self.opts).to('cpu')  # Ensuring net goes to CPU
self.sean_model = Pix2PixModel(SEAN_OPT).to('cpu')
self.rotate_model = RotateModel().to('cpu').eval()
self.post_process = PostProcessModel().to('cpu').eval()
```

4. **Input Data Preparation for CPU:**

When preparing your input data, ensure any transformations or tensor preparation is suitable for CPU:

```python
# Make sure your data is ready for CPU use
input_tensor = torch.randn(1, 3, 32, 32)  # On the CPU, no need for `.cuda()`
```

5. **Running the Inference:**

When running inference, there is no need to change the logic around the model's call, just ensure all components are set up to default to CPU:

```python
# Assuming you have a test run to use `hair_fast`
final_image = hair_fast.swap(face_img=face_path, shape_img=shape_path, color_img=color_path)

# Show or save the resulting image
```

### Conclusion

By ensuring all components of your model and input data reside on the CPU, you can seamlessly run your PyTorch models without needing access to a GPU. The primary changes involve setting device strategy and ensuring pre-trained model weights are mapped to the correct device during loading.

import torch
from torch import nn
from torch.nn import functional as F


class BicubicDownSample(nn.Module):
    def bicubic_kernel(self, x, a=-0.50):
        """
        This equation is exactly copied from the website below:
        https://clouard.users.greyc.fr/Pantheon/experiments/rescaling/index-en.html#bicubic
        """
        abs_x = torch.abs(x)
        if abs_x <= 1.:
            return (a + 2.) * torch.pow(abs_x, 3.) - (a + 3.) * torch.pow(abs_x, 2.) + 1
        elif 1. < abs_x < 2.:
            return a * torch.pow(abs_x, 3) - 5. * a * torch.pow(abs_x, 2.) + 8. * a * abs_x - 4. * a
        else:
            return 0.0

    def __init__(self, factor=4, cuda=True, padding='reflect'):
        super().__init__()
        self.factor = factor
        size = factor * 4
        k = torch.tensor([self.bicubic_kernel((i - torch.floor(torch.tensor(size / 2)) + 0.5) / factor)
                          for i in range(size)], dtype=torch.float32)
        k = k / torch.sum(k)
        # k = torch.einsum('i,j->ij', (k, k))
        k1 = torch.reshape(k, shape=(1, 1, size, 1))
        self.k1 = torch.cat([k1, k1, k1], dim=0)
        k2 = torch.reshape(k, shape=(1, 1, 1, size))
        self.k2 = torch.cat([k2, k2, k2], dim=0)
        self.cuda = '.cuda' if cuda else ''
        self.padding = padding
        for param in self.parameters():
            param.requires_grad = False

    def forward(self, x, nhwc=False, clip_round=False, byte_output=False):
        # x = torch.from_numpy(x).type('torch.FloatTensor')
        filter_height = self.factor * 4
        filter_width = self.factor * 4
        stride = self.factor

        pad_along_height = max(filter_height - stride, 0)
        pad_along_width = max(filter_width - stride, 0)
        filters1 = self.k1.type('torch{}.FloatTensor'.format(self.cuda))
        filters2 = self.k2.type('torch{}.FloatTensor'.format(self.cuda))

        # compute actual padding values for each side
        pad_top = pad_along_height // 2
        pad_bottom = pad_along_height - pad_top
        pad_left = pad_along_width // 2
        pad_right = pad_along_width - pad_left

        # apply mirror padding
        if nhwc:
            x = torch.transpose(torch.transpose(
                x, 2, 3), 1, 2)   # NHWC to NCHW

        # downscaling performed by 1-d convolution
        x = F.pad(x, (0, 0, pad_top, pad_bottom), self.padding)
        x = F.conv2d(input=x, weight=filters1, stride=(stride, 1), groups=3)
        if clip_round:
            x = torch.clamp(torch.round(x), 0.0, 255.)

        x = F.pad(x, (pad_left, pad_right, 0, 0), self.padding)
        x = F.conv2d(input=x, weight=filters2, stride=(1, stride), groups=3)
        if clip_round:
            x = torch.clamp(torch.round(x), 0.0, 255.)

        if nhwc:
            x = torch.transpose(torch.transpose(x, 1, 3), 1, 2)
        if byte_output:
            return x.type('torch.ByteTensor'.format(self.cuda))
        else:
            return x
RuntimeError: Input type (torch.FloatTensor) and weight type (torch.cuda.FloatTensor) should be the same or input should be a MKLDNN tensor and weight is a dense tensor

The error you're encountering suggests that there's a mismatch between the data type of your input tensor and your filter weights. Specifically, your filters are on the GPU (CudaTensor), but the input tensor is on the CPU (FloatTensor). To fix this, you need to ensure that both the input and filters are on the same device.

If you want the operation to be performed on the CPU, the solution is to avoid using `.cuda()` on your filter weights and to ensure both the weights and inputs are on the CPU. If you want to use the GPU, ensure both inputs and filters are moved to the GPU.

Here's a fixed version of your code that ensures operations are done on the CPU by removing CUDA-specific code. Note that I've removed references to `self.cuda` to simplify operations. This results in a CPU-only implementation:

```python
import torch
from torch import nn
from torch.nn import functional as F

class BicubicDownSample(nn.Module):
    def bicubic_kernel(self, x, a=-0.50):
        abs_x = torch.abs(x)
        if abs_x <= 1.:
            return (a + 2.) * torch.pow(abs_x, 3) - (a + 3.) * torch.pow(abs_x, 2) + 1
        elif 1. < abs_x < 2.:
            return a * torch.pow(abs_x, 3) - 5. * a * torch.pow(abs_x, 2) + 8. * a * abs_x - 4. * a
        else:
            return 0.0

    def __init__(self, factor=4, padding='reflect'):
        super().__init__()
        self.factor = factor
        size = factor * 4
        k = torch.tensor([self.bicubic_kernel((i - torch.floor(torch.tensor(size / 2)) + 0.5) / factor)
                          for i in range(size)], dtype=torch.float32)
        k = k / torch.sum(k)
        k1 = torch.reshape(k, shape=(1, 1, size, 1))
        self.k1 = torch.cat([k1, k1, k1], dim=0)
        k2 = torch.reshape(k, shape=(1, 1, 1, size))
        self.k2 = torch.cat([k2, k2, k2], dim=0)
        self.padding = padding
        for param in self.parameters():
            param.requires_grad = False

    def forward(self, x, nhwc=False, clip_round=False, byte_output=False):
        filter_height = self.factor * 4
        filter_width = self.factor * 4
        stride = self.factor

        pad_along_height = max(filter_height - stride, 0)
        pad_along_width = max(filter_width - stride, 0)
        
        # compute actual padding values for each side
        pad_top = pad_along_height // 2
        pad_bottom = pad_along_height - pad_top
        pad_left = pad_along_width // 2
        pad_right = pad_along_width - pad_left

        if nhwc:
            x = torch.transpose(torch.transpose(x, 2, 3), 1, 2)   # NHWC to NCHW

        x = F.pad(x, (0, 0, pad_top, pad_bottom), self.padding)
        x = F.conv2d(input=x, weight=self.k1, stride=(stride, 1), groups=3)
        if clip_round:
            x = torch.clamp(torch.round(x), 0.0, 255.)

        x = F.pad(x, (pad_left, pad_right, 0, 0), self.padding)
        x = F.conv2d(input=x, weight=self.k2, stride=(1, stride), groups=3)
        if clip_round:
            x = torch.clamp(torch.round(x), 0.0, 255.)

        if nhwc:
            x = torch.transpose(torch.transpose(x, 1, 3), 1, 2)
        if byte_output:
            return x.byte()
        else:
            return x
```

### Key Changes:

1. **Removed .cuda Usage**: This ensures that the operation runs on the CPU. If you ever want to move to a GPU, you can uncomment commands like `.cuda()` for both input tensors and weights.
  
2. **Tensor Type Transition**: Handles tensor conversion more explicitly than using string interpolation methods, e.g., `torch.cuda.ByteTensor`.

3. **Ensure Consistent Devices**: Both input and filters should reside on the same device. This example sticks to CPU (default in PyTorch).

Now, your module is configured to run only on CPU. To make it GPU-capable, you can add back GPU-specific logic with care so that inputs and weights match.

i,want,to,create,computer,vision,based,project,that,relates,to,high,scool,student,i,want,them,to,use,this,model,in,part,of,their,life

Creating a computer vision-based project that is relevant and engaging for high school students is a great initiative! The key is to ensure that the project is accessible, educational, and connects with their everyday experiences. Here’s a step-by-step guide on how you might set up such a project:

### Step 1: Define the Objective

First, decide on the specific problem or task your computer vision project will address for high school students. Here are a few ideas:
- **Homework Helper**: A model that recognizes math problems or text from a photo and provides explanations or resources.
- **Environmental Awareness**: An app that recognizes different types of plants, animals, or litter to promote environmental education and awareness.
- **Personal Safety**: A simple facial recognition system to log daily attendance without manual input.

### Step 2: Choose the Right Tools and Models

Select the tools and pre-trained models best suited for your project needs. Ideally, use models and platforms that are beginner-friendly, such as:
- **TensorFlow** and **Keras** for easy-to-use APIs.
- **PyTorch** for flexible and more research-oriented implementation.
- Pre-trained models like MobileNet, ResNet, or OpenCV for specific tasks (e.g., object detection or image classification).

### Step 3: Design a Simple User Interface

Create an interface that allows students to easily interact with the model. Options include:
- **Mobile Application**: Use frameworks like Flutter or React Native.
- **Web Application**: Implement with HTML/CSS/JavaScript and integrate the model using TensorFlow.js for browser execution.
- **Desktop Application**: Develop using Python with libraries like Tkinter or PyQt.

### Step 4: Develop and Train the Model

Depending on your chosen application, you may need to fine-tune a pre-trained model on a specific dataset. For high school students, you can simplify the process:
- **Data Collection**: Use publicly available datasets or collaborate with students to collect and label data.
- **Training**: Utilize platforms like Google Colab or Kaggle, which provide free GPU access.

### Step 5: Implement the Project

Your focus here should be making it user-friendly and ensuring it provides real value or engages students effortlessly.
- **Good Documentation**: Provide clear guides and tutorials on how to use and interpret the output from the model.
- **Feedback Loop**: Allow students to give feedback on the outputs to improve accuracy and relevance.

### Step 6: Test and Iterate

Test your application rigorously with a small group of students or beta testers. Gather feedback and make necessary adjustments to enhance usability and performance.

### Step 7: Educational Components

Integrate learning opportunities:
- **Workshops**: Conduct workshops or hackathons to teach students about the basics of AI, machine learning, and computer vision.
- **Challenges**: Create mini-challenges or competitions involving the project to stimulate interest and creativity.

### Examples of Computer Vision Projects for Students

1. **Art Recognition**: Identify famous artworks or artists from a picture, enhancing history or art class.
2. **Eco-Friendly Suggestions**: Identify recyclable materials or suggest waste disposal methods via object detection.
3. **Sport Skill Improvement**: Use pose estimation to give feedback on sports moves like shooting a basketball or gymnastics poses.

By aligning the project with aspects of their daily lives, you can enhance both educational value and engagement. Make sure that your final solution is scalable and easily accessible, whether on mobile, desktop, or online platforms.

give,me,more,idea,what,project,to,build,that,relates,to,high,school,students

Certainly! Here are some engaging computer vision project ideas geared towards high school students. Each idea attempts to integrate technology with aspects of their daily lives or educational experiences:

1. **Virtual Science Lab Assistant**:
   - **Objective**: Enhance science classes with an app that recognizes lab equipment or chemicals and provides safety tips or experiment instructions.
   - **How it Works**: Students can point their phone cameras at lab items to receive information or watch tutorial videos related to their science experiments.

2. **Interactive Historical Tour Guide**:
   - **Objective**: Make history interactive by allowing students to scan historical images, monuments, or artifacts with an app that provides detailed information and trivia.
   - **How it Works**: Use image recognition to fetch historical facts, timelines, and stories behind scanned objects, making history lessons more engaging.

3. **Personalized Study Helper**:
   - **Objective**: Develop a study app that recognizes text from textbooks or notes and quizzes students on the material.
   - **How it Works**: Text recognition can convert scanned pages into flashcards or quiz questions, aiding in test preparation.

4. **Art Explorer**:
   - **Objective**: Encourage appreciation for art by creating an app that identifies artists or art movements when students capture images of paintings or sculptures.
   - **How it Works**: Use object detection to classify art styles, providing immediate feedback and learning opportunities.

5. **Career Path Tracker**:
   - **Objective**: Develop a tool for exploring careers by recognizing equipment or scenarios related to different professions (medicine, engineering, etc.).
   - **How it Works**: The app provides interviews and resources on different career paths when users capture related images.

6. **Math Problem Solver**:
   - **Objective**: Assist with homework by developing an app that recognizes handwritten or textbook math problems and suggests solutions or similar problem types.
   - **How it Works**: Students take a picture of a math problem and receive step-by-step solutions or hints to solve similar problems.

7. **Fitness Coach**:
   - **Objective**: Promote physical education with an app that analyzes physical exercises and provides real-time feedback.
   - **How it Works**: Utilize pose estimation to assess form in exercises like push-ups or yoga and suggest improvements.

8. **Environmental Monitor**:
   - **Objective**: Increase awareness about local ecosystems by identifying plants and animals during nature walks via an app.
   - **How it Works**: Recognize flora and fauna, providing ecological information and enhancing biology education.

9. **Zero Waste Guide**:
   - **Objective**: Encourage recycling habits with an app that identifies waste items and suggests recycling methods.
   - **How it Works**: By scanning trash items, students learn how to recycle more efficiently and the impact of their actions.

10. **Cultural Diversity Amplifier**:
    - **Objective**: Build cultural awareness with an app that recognizes traditional clothing, symbols, or foods and provides information about different cultures.
    - **How it Works**: When students observe cultural symbols, the app shares fun facts, histories, and traditions.

11. **Mindfulness and Mental Health Coach**:
    - **Objective**: Develop a relaxation and mental health tool using mood detection to suggest activities.
    - **How it Works**: Recognizes facial expressions to gauge mood, recommending activities like meditation, breathing exercises, or motivational quotes.

These projects not only align with students' educational and personal experiences but also encourage them to interact with and enhance their environment using technology. They can serve as excellent capstone projects, science fair entries, or supplementary educational tools in school programs.

12 Days Kenya Safari!
Highlights:
x Aberdares: “Tree hotel”
x Lake Nakuru: “flamingos, rhinos and pelicans”
x Masai Mara: “wildebeest migration”
x Lake Naivasha: “Boat Trip, birdlife”
x Amboseli National Park: “Kilimanjaro on background”
x Ziwani Sanctuary "Walking safari, night game drives"
x Taita wildlife Sanctuary: “Community support”
x Tsavo East National Park: “Red elephants”
Day 1: 06.09.2024 - Arrival Nairobi – Eka Hotel. (B B)
Arrive at Jomo Kenyatta International Airport by an evening flight, after you clear with
immigrations our professional driver will be waiting for you with a warm smile, transfer to
the hotel where you will check in for dinner and overnight.
Day 2: 07.09.2024 - Aberdare National Park - The Ark (B L D )
After breakfast, drive to Aberdare National Park, this highland National Park offers a variety
of landscapes, from swampland, bamboo and fern forests to waterfalls and rivers. We proceed
to the beautiful lodge, The Ark check in in time for lunch, After lunch , you will enjoy the rest
of the afternoon and evening at the lookout corridor from which you may observe animals at
the waterhole close-by. A game drive through the park will be done and an optional hike to
the water falls. At night, the waterhole will attract special like rhinos, lions and leopards seek
to get some water. Dinner and overnight stay in the lodge.
Day 3: 08.09.2024 – Aberdares - Lake Nakuru – Ziwa Lodge (B L D)
After breakfast we will drive to Lake Elementaita, arrive and have lunch, in the afternoon we
will drive to Lake Nakuru National Park. Here, we visit Lake Nakuru as the most well-known
Best Memory Safaris Ltd, P. O. Box 157 - 80400 Ukunda
Diani Bazaar Shopping Center, Beach Road, Diani Beach, Room No. 3
Tel: <PRESIDIO_ANONYMIZED_PHONE_NUMBER> info@bestmemorysafaris.com www.bestmemorysafaris.com
BEST MEMORY SAFARIS LTD.
Selected Itineraries – Sustainable Travel – Excellent Sevice
lake of the Rift Valley. This park is famous all over the world for its flamingos; the lake is
one of the natural wonders of the world. At times, there are up to 2 million flamingos at the
lake, which form a beautiful pink ribbon around the shore. In addition to seeing this amazing
scenery, we also have a good chance of seeing rhinos and leopards.
Day 4: 09.09.2024 - Masai Mara National Park – Enkorok Mara Camp (B L D)
After breakfast we drive to the Masai Mara considered as one of the largest and most
beautiful protected areas of Kenya and reveal an insight into the originality of Africa. After
lunch on-site, we embark on the first game drive through the savannah landscape of the Masai
Mara Game Reserve, with a good chance to track down the Big Five (elephant, buffalo, lion,
rhino and leopard).
Day 5: 10.09.2024 - Masai Mara National Park – Enkorok Mara Camp (B L D)
Full day game drive in the Masai Mara. It is famous for its savannah landscape and its
wildlife. The prospects are good to observe all those fascinating animals that can usually only
be seen in numerous nature documentaries. We will have a picnic at the Mara River,
bordering the Serengeti. The river is part of the Masai Mara Serengeti ecosystem, which is
particularly known for the largest wildlife migration on earth in the world. Every year, the
huge animal trains cross the brown, foaming river full of crocodiles.
Day 6: 11.09.2024 - Lake Naivasha – Lake Naivasha Resort (B L D)
After breakfast we drive to Lake Naivasha. Lake Naivasha is the highest and most beautiful
lake in the Rift Valley, We arrive, check in and have our lunch, after lunch we will have some
time to relax before taking a boat tour to the lake where we will enjoy very beautiful views
and watch most of the aquatic birds found in this lake. We further take a walk at Crescent
Island where we will have the chance to watch the animals on foot. Overnight and dinner at
Lake Naivasha Resort.
Day 7: 12.09.2024 - Amboseli N.P.- Amboseli Sentrim Camp (B L D)
We drive to the Amboseli National park arriving at Amboseli sentrim Camp in time for lunch.
In the afternoon we are free to relax at the pool. In the evening take a guided walk through the
Masai villages around guided by a local masai . Dinner and overnight at Amboseli sentrim
Camp.
Best Memory Safaris Ltd, P. O. Box 157 - 80400 Ukunda
Diani Bazaar Shopping Center, Beach Road, Diani Beach, Room No. 3
Tel: <PRESIDIO_ANONYMIZED_PHONE_NUMBER> info@bestmemorysafaris.com www.bestmemorysafaris.com
BEST MEMORY SAFARIS LTD.
Selected Itineraries – Sustainable Travel – Excellent Sevice
Day 8: 13.09.2024 - Amboseli National Park – Amboseli Sentrim Camp (B L D)
Full day game drives in Amboseli National Park; this park has the best areas to observe
elephants at close quarters. The park has some swamplands in which animals are most likely
to be seen. From the park one can enjoy stunning views at Mt. Kilimanjaro, the most beautiful
mountain of Africa which makes a very beautiful background for your photos. Look out for
zebras, wildebeests, Thomson gazelles, Grant gazelles, buffalos, waterbucks, hippos, lions,
cheetahs, jackals and hyenas. We reach the Observation Hill from which we have a
magnificent view over swamp and savannah landscape of the whole park. This is where we
will have picnic lunch. We further continue with our game viewing and as the sun is going
down, we return to the Sentrim Camp for dinner and overnight.
Day 9: 14.09.2024 - Ziwani Voyager Wildlife Sanctuary – Voyager Ziwani Camp (B L D)
Today we drive to Voyager Ziwani wildlife Sanctuary, this wildlife sanctuary has very nice
walking routes which will give you the feeling of being close to the wild. Arrive and check at
our camp in time for lunch, after lunch we will arrive a short time at leisure which will be
followed by an evening walking safari in the sanctuary, with our guide we will discover
different species of birds, plants and animals. We will come in the evening where we will now
get to our vehicle and make a night game drive in the Sanctuary and have the chance of seeing
most of the nocturnal animals are hardly seen during the day. Come back at our Camp for
dinner and overnight.
Day 10: 15.09.2024 - Taita Hills Sanctuary – Saltlick Safari Lodge (B L D)
After breakfast, proceed to Taita hills Wildlife Sanctuary with game drive enroute as we drive
towards the lodge arriving in time for lunch at Saltlick safari Lodge. After lunch we have an
afternoon break, followed by the evening game drive through the Savannah grasslands, we
will come across Giraffes, Elephants, Baboons and other different species of animals. Dinner
and overnight stay at Saltlick Safari Lodge.
Day 11: 16.09.2024 - Tsavo East National park – Ashnil Aruba Lodge (B L D)
After an early morning game drive at the Sanctuary, we will come back for breakfast then we
drive to Tsavo East National Park, home of the “Red Elephants”. Enter the park and make
game drive enroute as we drive to the lodge arriving in time for lunch. After lunch we will
have some time to relax then go on another game drive in the afternoon. As the sun is going
down, we return to Ashnil Aruba Lodge for dinner and overnight.
Day 12: 17.09.2024 - Tsavo East - Diani Beach.
Best Memory Safaris Ltd, P. O. Box 157 - 80400 Ukunda
Diani Bazaar Shopping Center, Beach Road, Diani Beach, Room No. 3
Tel: <PRESIDIO_ANONYMIZED_PHONE_NUMBER> info@bestmemorysafaris.com www.bestmemorysafaris.com
BEST MEMORY SAFARIS LTD.
Selected Itineraries – Sustainable Travel – Excellent Sevice
We will make early morning games drives to explore the park further after which we will be
back for breakfast. We go on another safari after breakfast on our way to the gate look out for
the animals you missed to see in the previous game viewing, check out of the park and have
our lunch at a restaurant outside the gate of the park. Afterwards we drive to Diani beach
where we will drop and see you off for your beach holiday.
 Bitte auf deutsch übersetzen. 

12 Tage Safari in Kenia!

Höhepunkte:
- Aberdares: „Baumhotel“
- Lake Nakuru: „Flamingos, Nashörner und Pelikane“
- Masai Mara: „Wanderung der Gnus“
- Lake Naivasha: „Bootstour, Vogelwelt“
- Amboseli Nationalpark: „Kilimandscharo im Hintergrund“
- Ziwani Sanctuary: „Wandersafari, nächtliche Pirschfahrten“
- Taita Wildlife Sanctuary: „Gemeinschaftsunterstützung“
- Tsavo Ost Nationalpark: „Rote Elefanten“

Tag 1: 06.09.2024 - Ankunft in Nairobi – Eka Hotel. (F M A)
Ankunft am Jomo Kenyatta International Airport mit einem Abendflug. Nachdem Sie die Passkontrolle passiert haben, erwartet Sie unser professioneller Fahrer mit einem freundlichen Lächeln. Transfer zum Hotel, wo Sie einchecken und übernachten.

Tag 2: 07.09.2024 - Aberdare Nationalpark - The Ark (F M A)
Nach dem Frühstück Fahrt zum Aberdare Nationalpark, einem Hochland-Nationalpark mit vielfältigen Landschaften, von Sümpfen, Bambus- und Farnwäldern bis hin zu Wasserfällen und Flüssen. Ankunft an der wunderschönen Lodge The Ark, Einchecken rechtzeitig zum Mittagessen. Nach dem Mittagessen genießen Sie den Rest des Nachmittags und Abends im Aussichtskorridor, von dem aus Sie die Tiere am nahegelegenen Wasserloch beobachten können. Eine Pirschfahrt durch den Park wird ebenfalls durchgeführt und eine optionale Wanderung zu den Wasserfällen angeboten. Abends werden das Wasserloch besondere Tiere wie Nashörner, Löwen und Leoparden anziehen. Abendessen und Übernachtung in der Lodge.

Tag 3: 08.09.2024 - Aberdares - Lake Nakuru – Ziwa Lodge (F M A)
Nach dem Frühstück fahren wir zum Lake Elementaita, Ankunft und Mittagessen. Am Nachmittag fahren wir zum Lake Nakuru Nationalpark. Hier besuchen wir den Lake Nakuru, den bekanntesten See des Rift Valley. Dieser Park ist weltweit berühmt für seine Flamingos. Der See ist ein Naturwunder der Welt. Es gibt manchmal bis zu 2 Millionen Flamingos am See, die einen wunderschönen pinken Streifen um das Ufer bilden. Neben dieser beeindruckenden Kulisse haben wir gute Chancen, Nashörner und Leoparden zu sehen.

Tag 4: 09.09.2024 - Masai Mara Nationalpark – Enkorok Mara Camp (F M A)
Nach dem Frühstück fahren wir zur Masai Mara, einem der größten und schönsten Schutzgebiete Kenias. Nach dem Mittagessen vor Ort begeben wir uns auf die erste Pirschfahrt durch die Savannenlandschaft des Masai Mara Game Reserve mit guten Chancen, die Big Five (Elefant, Büffel, Löwe, Nashorn und Leopard) zu beobachten.

Tag 5: 10.09.2024 - Masai Mara Nationalpark – Enkorok Mara Camp (F M A)
Ganztägige Pirschfahrt in der Masai Mara, bekannt für ihre Savannenlandschaft und Tierwelt. Es gibt gute Chancen, all jene faszinierenden Tiere zu beobachten, die man sonst nur aus zahlreichen Naturdokumentationen kennt. Wir machen ein Picknick am Mara Fluss, der die Grenze zur Serengeti bildet und Teil des Masai Mara Serengeti Ökosystems ist. Dieses ist besonders bekannt für die größte Tierwanderung der Erde. Jedes Jahr überqueren riesige Herden von Tieren den braunen, schaumigen Fluss voller Krokodile.

Tag 6: 11.09.2024 - Lake Naivasha – Lake Naivasha Resort (F M A)
Nach dem Frühstück fahren wir zum Lake Naivasha, dem höchsten und schönsten See im Rift Valley. Ankunft, Einchecken und Mittagessen. Nach dem Mittagessen haben wir etwas Zeit zur Entspannung, bevor wir eine Bootstour auf dem See machen, die uns zu herrlichen Ausblicken und zur Beobachtung zahlreicher Wasservögel bringt. Wir machen weiter mit einem Spaziergang auf Crescent Island, wo wir die Möglichkeit haben, die Tiere zu Fuß zu beobachten. Übernachtung und Abendessen im Lake Naivasha Resort.

Tag 7: 12.09.2024 - Amboseli N.P.– Amboseli Sentrim Camp (F M A)
Wir fahren zum Amboseli Nationalpark und erreichen das Amboseli Sentrim Camp rechtzeitig zum Mittagessen. Am Nachmittag können Sie am Pool entspannen. Am Abend machen wir einen geführten Spaziergang durch die umliegenden Masai-Dörfer, geführt von einem lokalen Masai. Abendessen und Übernachtung im Amboseli Sentrim Camp.

Tag 8: 13.09.2024 - Amboseli Nationalpark – Amboseli Sentrim Camp (F M A)
Ganztägige Pirschfahrten im Amboseli Nationalpark, der besten Gegend, um Elefanten aus nächster Nähe zu beobachten. Der Park bietet schöne Sumpfgebiete, in denen Tiere häufig zu sehen sind. Vom Park aus kann man atemberaubende Ausblicke auf den Kilimandscharo genießen, den schönsten Berg Afrikas, der eine traumhafte Kulisse für Ihre Fotos bietet. Halten Sie Ausschau nach Zebras, Gnus, Thomson-Gazellen, Grant-Gazellen, Büffeln, Wasserböcken, Flusspferden, Löwen, Geparden, Schakalen und Hyänen. Wir erreichen den Observation Hill, von dem aus wir einen grandiosen Blick über die Sumpf- und Savannenlandschaft des gesamten Parks haben. Hier machen wir ein Picknick zum Mittagessen und setzen anschließend unsere Wildtierbeobachtung fort, bevor wir zum Sonnenuntergang zum Sentrim Camp für Abendessen und Übernachtung zurückkehren.

Tag 9: 14.09.2024 - Ziwani Voyager Wildlife Sanctuary – Voyager Ziwani Camp (F M A)
Heute fahren wir zum Voyager Ziwani Wildlife Sanctuary, das sehr schöne Wanderwege bietet, die Ihnen das Gefühl geben, der Wildnis nahe zu sein. Ankunft und Check-in im Camp rechtzeitig zum Mittagessen. Nach dem Mittagessen haben wir eine kurze Freizeit, gefolgt von einer abendlichen Wandersafari im Schutzgebiet. Mit unserem Guide entdecken wir verschiedene Vogelarten, Pflanzen und Tiere. Am Abend gehen wir zurück zu unserem Fahrzeug für eine nächtliche Pirschfahrt im Schutzgebiet, die uns die Möglichkeit bietet, die meisten nachtaktiven Tiere zu sehen, die tagsüber kaum zu sehen sind. Rückkehr ins Camp für Abendessen und Übernachtung.

Tag 10: 15.09.2024 - Taita Hills Sanctuary – Saltlick Safari Lodge (F M A)
Nach dem Frühstück geht es weiter zum Taita Hills Wildlife Sanctuary mit einer Pirschfahrt auf dem Weg zur Lodge, die wir zur Mittagszeit in der Saltlick Safari Lodge erreichen. Nach dem Mittagessen Nachmittagspause, gefolgt von einer abendlichen Pirschfahrt durch die Savannengraslandschaften, bei der wir auf Giraffen, Elefanten, Paviane und andere verschiedene Tierarten treffen. Abendessen und Übernachtung in der Saltlick Safari Lodge.

Tag 11: 16.09.2024 - Tsavo Ost Nationalpark – Ashnil Aruba Lodge (F M A)
Nach einer frühen morgendlichen Pirschfahrt im Sanctuary kehren wir zum Frühstück zurück und fahren dann zum Tsavo Ost Nationalpark, der Heimat der „Roten Elefanten“. Wir betreten den Park und fahren, während wir auf dem Weg zur Lodge Wildbeobachtungen machen, wo wir rechtzeitig zum Mittagessen ankommen. Nach dem Mittagessen haben wir etwas Zeit zur Entspannung, bevor wir am Nachmittag auf eine weitere Pirschfahrt gehen. Zum Sonnenuntergang kehren wir zur Ashnil Aruba Lodge für Abendessen und Übernachtung zurück.

Tag 12: 17.09.2024 - Tsavo Ost – Diani Beach
Wir machen frühmorgens Pirschfahrten, um den Park weiter zu erkunden, nach denen wir zum Frühstück zurückkehren. Wir machen eine weitere Safari nach dem Frühstück auf dem Weg zum Parkausgang, um nach Tieren Ausschau zu halten, die wir bei der vorherigen Wildbeobachtung verpasst haben. Ausfahrt aus dem Park und Mittagessen in einem Restaurant außerhalb des Parktors. Anschließend fahren wir zum Diani Beach, wo wir Sie zu Ihrem Strandurlaub absetzen und verabschieden.

hi

Hello! How can I assist you today?

что такое ci release

CI (Continuous Integration) release часто относится к практике автоматизации процесса интеграции изменений в код в основной кодовой базе и подготовки его для релиза. Эта практика является частью более широких методологий CI/CD (Continuous Integration/Continuous Deployment или Continuous Delivery).

Основные аспекты CI release включают:

1. **Автоматизация сборки**: Каждый раз, когда разработчик вносит изменения в код, эти изменения автоматически объединяются в общую кодовую базу и проходят процесс сборки, чтобы убедиться, что они не нарушают существующую функциональность.

2. **Тестирование**: Автоматическое тестирование кода для выявления ошибок на ранней стадии. Это может включать в себя юнит-тесты, интеграционные тесты и другие типы тестов.

3. **Интеграция**: Изменения часто интегрируются в основной код для того, чтобы избежать проблем, которые могут возникнуть при накоплении большого количества изменений.

4. **Подготовка к релизу**: После успешного прохождения всех тестов изменения могут быть автоматически подготовлены для релиза. Это может включать в себя упаковку приложения, обновление версий и передаче его в следующий этап развертывания.

5. **Обратная связь**: Системы CI предоставляют разработчикам обратную связь о статусе сборок и тестов, что помогает быстро выявлять и устранять проблемы.

CI release способствует более быстрому и надежному процессу разработки, снижая риск ошибок и упрощая поддержку и улучшение программного обеспечения.

can you use the adverb expensively in a sentence 

Certainly! Here’s a sentence using the adverb "expensively": 

"She dressed expensively for the gala, wearing a designer gown and dazzling jewelry."

We use the before superlative adjectives. we should say we use the before a superlative  adjectives

You're correct that the definite article "the" is typically used before superlative adjectives. Superlative adjectives describe the highest degree of a quality among three or more subjects. Here's an example: "She is the tallest person in the room." 

If you have another context or example in mind that you'd like to discuss, feel free to let me know!