Przejdź do treści
Biblioteka skilli
AI i agenci · Budowanie i kod

transformers

/transformers

Pomaga pracować z wstępnie wytrenowanymi modelami transformer w tekście, obrazie, audio i multimodalności, także przy dostrajaniu.

Repozytorium
openscience ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
25.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
6
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Pomaga pracować z wstępnie wytrenowanymi modelami transformer w tekście, obrazie, audio i multimodalności, także przy dostrajaniu.

Oryginalny opis (EN)

This skill should be used when working with pre-trained transformer models for natural language processing, computer vision, audio, or multimodal tasks. Use for text generation, classification, question answering, translation, summarization, image classification, object detection, speech recognition, and fine-tuning models on custom datasets.

Jak działa

  1. Overview
  2. Installation
  3. Credential Setup
  4. Quick Start
  5. Core Capabilities
  6. Common Patterns
  7. Reference Documentation
Sekcje z nagłówków SKILL.md, w oryginale · 149 linii, 538 słów
Podgląd SKILL.md
---
name: transformers
description: This skill should be used when working with pre-trained transformer models for natural language processing, computer vision, audio, or multimodal tasks. Use for text generation, classification, question answering, translation, summarization, image classification, object detection, speech recognition, and fine-tuning models on custom datasets.
category: llm-tools
license: Apache-2.0 license
compatibility: Some features require an Huggingface token
metadata:
    upstream: K-Dense-AI/scientific-agent-skills
    upstream-url: https://github.com/K-Dense-AI/scientific-agent-skills
    upstream-path: skills/transformers
    upstream-license: MIT
    upstream-relationship: derived
    adapted-by: Synthetic Sciences
    skill-author: K-Dense Inc.
version: 1.0.0
author: K-Dense Inc.
tags: [NLP, Deep Learning, Hugging Face, LLM, Fine-Tuning]
dependencies: ["transformers>=4.45.0", "torch>=2.0.0", "tokenizers>=0.19.0"]
---

# Transformers

## Overview

The Hugging Face Transformers library provides access to thousands of pre-trained models for tasks across NLP, computer vision, audio, and multimodal domains. Use this skill to load models, perform inference, and fine-tune on custom data.

## Installation

Install transformers and core dependencies:

```bash
uv pip install torch transformers datasets evaluate accelerate
```

For vision tasks, add:
```bash
uv pip install timm pillow
```

For audio tasks, add:
```bash
uv pip install librosa soundfile
```

## Credential Setup

HuggingFace token is auto-injected by openscience when connected via the dashboard.

```bash
# Verify credentials
[ -n "$HF_TOKEN" ] && echo "HF_TOKEN set" || echo "NOT SET"
```

If not set: add your Hugging Face token in Customize → Tools or export `HF_TOKEN` locally.

## Quick Start

Use the Pipeline API for fast inference without manual configuration:

```python
from transformers import pipeline

# Text generation
generator = pipeline("text-generation", model="gpt2")
result = generator("The future of AI is", max_length=50)

# Text classification
classifier = pipeline("text-classification")
result = classifier("This movie was excellent!")

# Question answering
qa = pipeline("question-answering")
result = qa(question="What is AI?", context="AI is artificial intelligence...")
```

## Core Capabilities

### 1. Pipelines for Quick Inference

Use for simple, optimized inference across many tasks. Supports text generation, classification, NER, question answering, summarization, translation, image classification, object detection, audio classification, and more.

**When to use**: Quick prototyping, simple inference tasks, no custom preprocessing needed.

See `references/pipelines.md` for comprehensive task coverage and optimization.

### 2. Model Loading and Management

Load pre-trained models with fine-grained control over configuration, device placement, and precision.

**When to use**: Custom model initialization, advanced device management, model inspection.

See `references/models.md` for loading patterns and best practices.

### 3. Text Generation

Generate text with LLMs using various decoding strategies (greedy, beam search, sampling) and control parameters (temperature, top-k, top-p).

**When to use**: Creative text generation, code generation, conversational AI, text completion.

See `references/generation.md` for generation strategies and parameters.

### 4. Training and Fine-Tuning

Fine-tune pre-trained models on custom datasets using the Trainer API with automatic mixed precision, distributed training, and logging.

**When to use**: Task-specific model adaptation, domain adaptation, improving model performance.

See `references/training.md` for training workflows and best practices.

### 5. Tokenization

Convert text to tokens and token IDs for model input, with padding, truncation, and special token handling.

**When to use**: Custom preprocessing pipelines, understanding model inputs, batch processing.

See `references/tokenizers.md` for tokenization details.

## Common Patterns

### Pattern 1: Simple Inference
For straightforward tasks, use pipelines:
```python
pipe = pipeline("task-name", model="model-id")
output = pipe(input_data)
```

### Pattern 2: Custom Model Usage
For advanced control, load model and tokenizer separately:
```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("model-id")
model = AutoModelForCausalLM.from_pretrained("model-id", device_map="auto")

inputs = tokenizer("text", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])
```

### Pattern 3: Fine-Tuning
For task adaptation, use Trainer:
```python
from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=8,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
)

trainer.train()
```

## Reference Documentation

For detailed information on specific components:
- **Pipelines**: `references/pipelines.md` - All supported tasks and optimization
- **Models**: `references/models.md` - Loading, saving, and configuration
- **Generation**: `references/generation.md` - Text generation strategies and parameters
- **Training**: `references/training.md` - Fine-tuning with Trainer API
- **Tokenizers**: `references/tokenizers.md` - Tokenization and preprocessing
Pliki w paczce (6)
  • SKILL.md 5 KB
  • references/generation.md 9 KB
  • references/models.md 8 KB
  • references/pipelines.md 9 KB
  • references/tokenizers.md 10 KB
  • references/training.md 10 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · synthetic-sciences/openscience100Apache-2.0
lamm-mit/scienceclaw100Apache-2.0
bestagentkits/agency-skills100MIT
davila7/claude-code-templates95MIT

Migawka bazy z 13.11.2026 · wersja paczki 9acc48cfe71b (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 95transformers-js
    Uruchamia modele Hugging Face w JavaScript lub TypeScript przez Transformers.js w przeglądarce lub Node.js, bez backendu Python.
  • 95huggingface-transformers
    Opisuje dobre praktyki pracy z Hugging Face Transformers: ładowanie modeli, tokenizację, dostrajanie, zadania NLP i optymalizację wnioskowania.
  • 100alterlab-transformers
    Ładuje, uruchamia i dostraja wstępnie wytrenowane modele w Hugging Face Transformers v5: pipeline do generowania tekstu, klasyfikacji, NER i rozpoznawania mowy, kwantyzacja i fine-tuning z LoRA.
  • 100transformers-inference
    Uruchamia wnioskowanie modeli Transformers do klasyfikacji, NER, pytań, streszczeń i embeddingów, bez trenowania dużych modeli.
  • 100processing-computer-vision-tasks
    Przetwarza obrazy za pomocą wykrywania obiektów, klasyfikacji i segmentacji, przy analizie obrazu i zadaniach widzenia komputerowego.
  • 100processing-computer-vision-tasks
    Przetwarza obrazy za pomocą wykrywania obiektów, klasyfikacji i segmentacji, przy analizie obrazu i zadaniach widzenia komputerowego.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.