File size: 7,599 Bytes
316492d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 |
# -*- coding: utf-8 -*-
"""Untitled6.ipynb
Automatically generated by Colab.
Original file is located at
https://colab.research.google.com/drive/1b3-0ogrDvdw3WtHwOta0Ihlo46MAwDsk
"""
!pip install requests transformers
import requests
import zipfile
import os
# URL du fichier zip sur Hugging Face
zip_url = 'https://huggingface.co/datasets/Dabococo/wheeloh_dataset/images'
# Nom local du fichier zip
zip_file = 'images.zip'
# Télécharger le fichier zip
response = requests.get(zip_url)
content_type = response.headers.get('Content-Type')
# Vérifier que le fichier est un fichier zip
if 'zip' not in content_type:
raise ValueError("Le fichier téléchargé n'est pas un fichier zip. Content-Type: {}".format(content_type))
# Sauvegarder le contenu téléchargé dans un fichier
with open(zip_file, 'wb') as f:
f.write(response.content)
# Vérifier la taille du fichier
file_size = os.path.getsize(zip_file)
print("Taille du fichier téléchargé:", file_size, "octets")
# Afficher le début du contenu du fichier pour vérifier
with open(zip_file, 'rb') as f:
print(f.read(100)) # Lire les 100 premiers octets
# Créer un répertoire pour extraire les fichiers
extract_dir = 'extracted_files'
os.makedirs(extract_dir, exist_ok=True)
# Extraire le contenu du fichier zip
try:
with zipfile.ZipFile(zip_file, 'r') as zip_ref:
zip_ref.extractall(extract_dir)
# Afficher les fichiers extraits
extracted_files = os.listdir(extract_dir)
print("Fichiers extraits :", extracted_files)
except zipfile.BadZipFile:
print("Erreur : le fichier téléchargé n'est pas un fichier zip valide.")
from torchvision.datasets import ImageFolder
import os
from torchvision.datasets.folder import has_file_allowed_extension, IMG_EXTENSIONS, default_loader
class CustomImageFolder(ImageFolder):
def __init__(self, root, transform=None, loader=default_loader, is_valid_file=None):
super().__init__(root, transform=transform, loader=loader, is_valid_file=is_valid_file)
def find_classes(self, directory):
# Ignorer les répertoires cachés
classes = [d.name for d in os.scandir(directory) if d.is_dir() and not d.name.startswith('.')]
classes.sort()
class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)}
return classes, class_to_idx
def make_dataset(self, directory, class_to_idx, extensions=None, is_valid_file=None, allow_empty=False):
instances = []
directory = os.path.expanduser(directory)
both_none = extensions is None and is_valid_file is None
if both_none:
raise ValueError("Both extensions and is_valid_file cannot be None")
if extensions is not None:
def is_valid_file(x):
return has_file_allowed_extension(x, extensions)
for target_class in sorted(class_to_idx.keys()):
class_index = class_to_idx[target_class]
target_dir = os.path.join(directory, target_class)
if not os.path.isdir(target_dir):
continue
for root, _, fnames in sorted(os.walk(target_dir)):
for fname in sorted(fnames):
path = os.path.join(root, fname)
if is_valid_file(path) and not fname.startswith('.'):
item = path, class_index
instances.append(item)
if not allow_empty and len(instances) == 0:
raise RuntimeError(f"Found 0 files in subfolders of: {directory}. Supported extensions are: {','.join(extensions)}")
return instances
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import transforms, models
from tqdm import tqdm
# Configuration
batch_size = 32
num_epochs = 10
learning_rate = 0.001
num_classes = 2
# Préparer les transformations
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
# Charger les données d'entraînement avec CustomImageFolder
train_dataset = CustomImageFolder(root='/content/dataset/train', transform=transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True)
# Définir le modèle
model = models.resnet18(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, num_classes)
model = model.to('cuda')
# Définir la perte et l'optimiseur
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
# Utiliser le scaler pour l'AMP
scaler = torch.cuda.amp.GradScaler()
# Entraînement
for epoch in range(num_epochs):
model.train()
running_loss = 0.0
for inputs, labels in tqdm(train_loader):
inputs, labels = inputs.to('cuda'), labels.to('cuda')
# Zero the parameter gradients
optimizer.zero_grad()
# Forward pass with autocast
with torch.cuda.amp.autocast():
outputs = model(inputs)
loss = criterion(outputs, labels)
# Backward pass with scaler
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
running_loss += loss.item() * inputs.size(0)
epoch_loss = running_loss / len(train_loader.dataset)
print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {epoch_loss:.4f}')
print('Finished Training')
# Sauvegarder le modèle
torch.save(model.state_dict(), 'model.pth')
#Ici pour charger le modèle
import torch
import torch.nn as nn
from torchvision import models, transforms
from PIL import Image
# Définir le modèle
num_classes = 2 # Canard et Perroquet
model = models.resnet18(pretrained=False)
model.fc = nn.Linear(model.fc.in_features, num_classes)
model = model.to('cuda')
# Charger les poids du modèle enregistré
model.load_state_dict(torch.load('model.pth'))
model.eval() # Mettre le modèle en mode évaluation
# Définir les transformations
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
# Charger et transformer une nouvelle image
def load_image(image_path):
image = Image.open(image_path).convert('RGB')
image = transform(image)
image = image.unsqueeze(0) # Ajouter une dimension pour le batch
return image
# Exemple de chargement d'une image
image_path = '/content/lg.jpeg'
image = load_image(image_path).to('cuda')
# Passer l'image dans le modèle pour obtenir des prédictions
with torch.no_grad(): # Désactiver la grad pour l'inférence
outputs = model(image)
_, predicted = torch.max(outputs, 1)
classes = ['Alpine', 'Bugatti']
predicted_class = classes[predicted.item()]
print(f'Predicted class: {predicted_class}')
!pip install transformers huggingface_hub
!huggingface-cli login
from huggingface_hub import HfApi, HfFolder, Repository
# Variables
model_path = "Wheeloh-model_1.pth"
repo_name = "Wheeloh-model_1" # Remplacez par le nom de votre dépôt
commit_message = "Initial commit"
# Se connecter à l'API
api = HfApi()
# Obtenir le token d'authentification
token = HfFolder.get_token()
# Cloner le dépôt Hugging Face
repo_url = api.create_repo(repo_name, token=token, exist_ok=True)
repo = Repository(local_dir=repo_name, clone_from=repo_url)
# Copier le fichier du modèle dans le dépôt local
import shutil
shutil.copy(model_path, repo_name)
# Pousser le modèle sur le hub
repo.push_to_hub(commit_message=commit_message) |