from transformers import GPT2Tokenizer, GPT2LMHeadModel, pipeline
 
tokenizer = GPT2Tokenizer.from_pretrained("gpt2-large", cache_dir="cache")
model = GPT2LMHeadModel.from_pretrained("gpt2-large", cache_dir="cache")
 
generator = pipeline(model=model, tokenizer=tokenizer, task="text-generation", max_new_tokens=10, early_stopping=True)
 
result = generator("algebra is the science of")
 
print(result)

#pip install einops
 
from transformers import AutoTokenizer, AutoModelForCausalLM
import transformers
import torch
 
model = "tiiuae/falcon-40b"
 
tokenizer = AutoTokenizer.from_pretrained(model, cache_dir="falcon40b")
pipeline = transformers.pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.bfloat16,
    trust_remote_code=True,
    device_map="auto",
)
sequences = pipeline(
   "AI is going to replace humans because",
    max_length=100,
    do_sample=True,
    top_k=10,
    num_return_sequences=1,
    eos_token_id=tokenizer.eos_token_id,
)
for seq in sequences:
    print(f"Result: {seq['generated_text']}")

Siehe auch Yolov5.

from transformers import DetrImageProcessor, DetrForObjectDetection
import torch
from PIL import Image
import requests
 
url = "https://bilder.ottoversand.at/i/empiriecom/c6d7b41b9382cccd4b131c48a1306ac4"
image = Image.open(requests.get(url, stream=True).raw)
 
processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-101")
model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-101")
 
inputs = processor(images=image, return_tensors="pt")
outputs = model(**inputs)
 
# convert outputs (bounding boxes and class logits) to COCO API
# let's only keep detections with score > 0.9
target_sizes = torch.tensor([image.size[::-1]])
results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)[0]
 
for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
    box = [round(i, 2) for i in box.tolist()]
    print(f"Detected {model.config.id2label[label.item()]} with confidence {round(score.item(), 3)} at location {box}")

from transformers import pipeline
from PIL import Image, ImageDraw, ImageFont
from transformers import DetrFeatureExtractor, DetrForObjectDetection
 
#classifier = pipeline("sentiment-analysis")
#classifier = pipeline("feature-extraction")
#classifier = pipeline("question-answering")
#classifier = pipeline("text-generation", model="gpt2")
 
feature_extractor = DetrFeatureExtractor.from_pretrained('facebook/detr-resnet-101')
model = DetrForObjectDetection.from_pretrained('facebook/detr-resnet-101')
object_detector = pipeline("object-detection", model = model, feature_extractor = feature_extractor)
 
def draw_bounding_box(im, score, label, xmin, ymin, xmax, ymax, index, num_boxes):
    im_with_rectangle = ImageDraw.Draw(im)  
    im_with_rectangle.rounded_rectangle((xmin, ymin, xmax, ymax), outline = "red", width = 5, radius = 10)
    im_with_rectangle.text((xmin+10, ymin+10), label, fill="white", stroke_fill = "red")
    return im, label
 
with Image.open("test.jpg") as im:
    bounding_boxes = object_detector(im)
    num_boxes = len(bounding_boxes)
    index = 0
    labels = []
    for bounding_box in bounding_boxes:
        box = bounding_box["box"]
        im, label = draw_bounding_box(im, bounding_box["score"], bounding_box["label"], box["xmin"], box["ymin"], box["xmax"], box["ymax"], index, num_boxes)
        #if label not in labels:
        labels.append(label)
        index += 1
    #im.save("boxes.jpg")
    im.show()
    print(labels)

from transformers import ViTImageProcessor, ViTForImageClassification
from PIL import Image
import requests
 
url = 'https://rothys.com/cdn/shop/files/05.31_HP_3_Desktop_9nsINbZq8H.jpg?v=1685080183&width=1024'
image = Image.open(requests.get(url, stream=True).raw)
 
processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224')
model = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224')
 
inputs = processor(images=image, return_tensors="pt")
outputs = model(**inputs)
logits = outputs.logits
# model predicts one of the 1000 ImageNet classes
predicted_class_idx = logits.argmax(-1).item()
print("Predicted class:", model.config.id2label[predicted_class_idx])