Food-Classification-AI-Model

132

1

1 language

—

by

AventIQ-AI

Other

OTHER

New

132 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

Unknown

Mobile

Laptop

Server

Quick Summary

AI model with specialized capabilities.

Code Examples

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Load model and processorpythontransformers

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize

# Load model and processor
model_name = "AventIQ-AI/Food-Classification-AI-Model"

model = AutoModelForImageClassification.from_pretrained("your-model-path")
processor = AutoImageProcessor.from_pretrained("your-model-path")

def predict(image_path):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    image = Image.open(image_path).convert("RGB")
    transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize(mean=processor.image_mean, std=processor.image_std)
    ])
    pixel_values = transform(image).unsqueeze(0).to(device)

    with torch.no_grad():
        outputs = model(pixel_values=pixel_values)
        logits = outputs.logits
        predicted_idx = logits.argmax(-1).item()
        predicted_label = model.config.id2label[predicted_idx]
    
    return predicted_label

# Example usage:
print(predict("Foodexample.jpg"))

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.