পাইটর্চে ফাস্ট নিউরাল স্টাইল ট্রান্সফার ও Core ML এ কনভার্ট

conda create -n env_name python=3.12

conda activate env_name 

conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

nvidia-smi 

nvcc --version

import torch
print("CUDA Available: ", torch.cuda.is_available())

conda install pytorch torchvision torchaudio cpuonly -c pytorch

python neural_style/neural_style.py train --dataset </path/to/train-dataset> --style-image </path/to/style/image> --save-model-dir </path/to/save-model/folder> --epochs 2 --cuda 1

 python neural_style/neural_style.py train \
--dataset ./train2014 \
--style-image ./images/style-images/candy.jpg \
--epochs 2 \
--batch-size 4 \
--image-size 256 \
--content-weight 1e5 \
--style-weight 1e10 \
--lr 1e-3 \
--save-model-dir ./models
--cuda 1

python neural_style/neural_style.py eval --content-image </path/to/content/image> --model </path/to/saved/model> --output-image </path/to/output/image> --cuda 0

python neural_style/neural_style.py eval \
--content-image images/content-images/amber.jpg \
--model models/result.model \
--output-image output.jpg \
--cuda 0

conda create -n coreML python=3.10

conda activate coreML

pip install torch
pip install torchvision
pip install -U coremltools

import torch
import coremltools as ct
import sys
import os

# Add the 'neural_style' directory to the system path
sys.path.append(os.path.join(os.path.dirname(__file__), 'neural_style'))



# Now import TransformerNet
from transformer_net import TransformerNet

# Load the saved model state_dict
model = TransformerNet()

# Modify the state_dict to remove running_mean and running_var keys
state_dict = torch.load('models/result.model')

# Filter out the running_mean and running_var keys
for key in list(state_dict.keys()):
    if "running_mean" in key or "running_var" in key:
        del state_dict[key]

# Load the filtered state_dict into the model
model.load_state_dict(state_dict)
model.eval()  # Set the model to evaluation mode

#  input shape for tracing (adjust the size as per your input dimensions)
input_shape = torch.randn(1, 3, 1000, 1000)

# Trace the model using torch.jit.trace
traced_model = torch.jit.trace(model, input_shape)

# Convert to Core ML using coremltools
coreml_model = ct.convert(
    traced_model,
    inputs=[ct.ImageType(name="input", shape=input_shape.shape)],  # Specify input as an image
    outputs=[ct.ImageType(name="output",  scale=1, bias=[0, 0, 0])]  # Specify output as an image
)

# Save the Core ML model
coreml_model.save('coreml-output/result.mlpackage')

print("Model successfully converted and saved as 'coreml-output/result.mlpackage'")

python  converter.py

    // Function to Make Art from the image using Core ML
    func makeArt(_ image: UIImage) {
        do {
            let modelConfiguration = MLModelConfiguration()
            // Load yoru model
            let model = try VNCoreMLModel(for: Candy(configuration: modelConfiguration).model)
            
            let request = VNCoreMLRequest(model: model) { request, error in
                if let results = request.results as? [VNPixelBufferObservation],
                   let pixelBuffer = results.first?.pixelBuffer {
                    
                    // Convert the pixel buffer to CIImage
                    let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
                    let context = CIContext()
                    
                    // Create CGImage
                    if let cgImage = context.createCGImage(ciImage, from: ciImage.extent) {
                        // Convert CGImage to UIImage
                        self.output = UIImage(cgImage: cgImage)
                        // Use the processed UIImage (uiImage)
                    }
                } else {
                    print("No results or invalid format")
                }
            }
            
            // Load the image from the Assets
            if  let cgImage = image.cgImage {
                let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
                try handler.perform([request])
            }
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }

import SwiftUI
import CoreML
import Vision
import UIKit

struct ContentView: View {
    @State private var image: UIImage? = nil
    @State private var output: UIImage? = nil
    @State private var isImagePickerPresented: Bool = false
    
    
    
    var body: some View {
        VStack {
            ScrollView{
                if let image = image {
                    Image(uiImage: image)
                        .resizable()
                        .scaledToFit()
                        .frame(height: 300)
                        .padding()
                    
                    HStack{
                        Button("Make Art") {
                            makeArt(image)
                        }
                    }
                }
                
                if let output = output{
                    Image(uiImage: output)
                        .resizable()
                        .scaledToFit()
                        .frame(height: 300)
                        .padding()
                    
                    Button("Save"){
                        UIImageWriteToSavedPhotosAlbum(output, nil, nil, nil)
                    }
                }
                
                Button("Pick an Image") {
                    isImagePickerPresented = true
                }
            }
            .padding()
        }
        .sheet(isPresented: $isImagePickerPresented, content: {
            ImagePicker(selectedImage: $image, sourceType: .photoLibrary)
        })
    }
    
    // Function to Make Art from the image using Core ML
    func makeArt(_ image: UIImage) {
        do {
            let modelConfiguration = MLModelConfiguration()
            // Load yoru model
            let model = try VNCoreMLModel(for: Candy(configuration: modelConfiguration).model)
            
            let request = VNCoreMLRequest(model: model) { request, error in
                if let results = request.results as? [VNPixelBufferObservation],
                   let pixelBuffer = results.first?.pixelBuffer {
                    
                    // Convert the pixel buffer to CIImage
                    let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
                    let context = CIContext()
                    
                    // Create CGImage
                    if let cgImage = context.createCGImage(ciImage, from: ciImage.extent) {
                        // Convert CGImage to UIImage
                        self.output = UIImage(cgImage: cgImage)
                        // Use the processed UIImage (uiImage)
                    }
                } else {
                    print("No results or invalid format")
                }
            }
            
            // Load the image from the Assets
            if  let cgImage = image.cgImage {
                let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
                try handler.perform([request])
            }
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }
    
    // ImagePicker helper to allow the user to pick an image
    struct ImagePicker: UIViewControllerRepresentable {
        @Binding var selectedImage: UIImage?
        @Environment(\.presentationMode) var presentationMode
        var sourceType: UIImagePickerController.SourceType = .photoLibrary
        
        class Coordinator: NSObject, UINavigationControllerDelegate, UIImagePickerControllerDelegate {
            let parent: ImagePicker
            
            init(parent: ImagePicker) {
                self.parent = parent
            }
            
            func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
                if let image = info[.originalImage] as? UIImage {
                    parent.selectedImage = image
                }
                parent.presentationMode.wrappedValue.dismiss()
            }
            
            func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
                parent.presentationMode.wrappedValue.dismiss()
            }
        }
        
        func makeCoordinator() -> Coordinator {
            Coordinator(parent: self)
        }
        
        func makeUIViewController(context: UIViewControllerRepresentableContext<ImagePicker>) -> UIImagePickerController {
            let picker = UIImagePickerController()
            picker.delegate = context.coordinator
            picker.sourceType = sourceType
            return picker
        }
        
        func updateUIViewController(_ uiViewController: UIImagePickerController, context: UIViewControllerRepresentableContext<ImagePicker>) {}
    }   
}
#Preview {
    ContentView()
}