SSD Nodes Learn Hosting plans →
Przewodniki Matt ConnorAutor: Matt Connor · Zaktualizowano 2026-10-15

Jak ustawić reasoning effort w lokalnym modelu LLM

Dowiedz się, jak parametr reasoning effort wpływa na czas generowania odpowiedzi w lokalnych modelach LLM. Sprawdź, jak mierzyć koszt obliczeniowy w tokenach i czasie.

Jak zmienia się nakład pracy modelu przy lokalnym LLM

Nakład pracy modelu (reasoning effort) to ustawienie określające, jak długo model ma analizować zagadnienie przed udzieleniem odpowiedzi. Zmienia ono wyłącznie długość segmentu rozumowania. Wagi na dysku pozostają identyczne na każdym poziomie, kwantyzacja jest taka sama, a odpowiedź generowana jest w tym samym przebiegu (forward pass). Zmienia się jedynie liczba tokenów, które model poświęca na własny notatnik przed przystąpieniem do odpowiedzi.

To rozróżnienie jest istotne ze względu na miejsce, w którym te tokeny są przetwarzane. W przypadku hostowanego API tokeny rozumowania są uwzględniane na fakturze. Na własnym VPS płaci się za nie czasem generowania na własnym CPU lub GPU oraz zajętym miejscem w oknie kontekstowym. Model ustawiony na najwyższy poziom wysiłku może poświęcić większość wyjścia na rozumowanie, zanim pojawi się pierwsze słowo odpowiedzi. Na własnym sprzęcie oznacza to różnicę między dwusekundową a dwuminutową reakcją.

Gdzie znajduje się poziom: szablon czatu, a nie wagi

Model myślący jest trenowany do generowania segmentu rozumowania, zazwyczaj zawartego w znacznikach <think> oraz </think>, przed udzieleniem ostatecznej odpowiedzi. Poziom wysiłku to instrukcja, którą szablon czatu modelu zapisuje w prompcie. Szablon ten jest plikiem Jinja dostarczanym wraz z modelem. Odczytuje on zmienną taką jak reasoning_effort i renderuje inną linię na poziomie systemowym dla każdej wartości, a model został wytrenowany do skracania lub wydłużania swojego notatnika w odpowiedzi na tę linię.

Wynikają z tego dwie kwestie. Nazwy poziomów należą do modelu, a nie do środowiska uruchomieniowego, więc nazwa z karty jednego modelu może nic nie znaczyć dla innego. Jeśli cokolwiek w łańcuchu zamieni szablon czatu modelu na ogólny, zmienna nigdy nie zostanie wyrenderowana, a ustawienie po cichu nie przyniesie żadnego efektu.

Sprawdzono 2026-10-12, karta modelu Qwen3.8-27B dokumentuje trzy poziomy wysiłku: low, medium oraz xhigh, z xhigh jako wartością domyślną. Nie istnieje high. Samo myślenie przełącza się za pomocą enable_thinking, które jest domyślnie włączone; karta dokumentuje również preserve_thinking, domyślnie włączone, które zachowuje rozumowanie z wcześniejszych tur historii konwersacji. gpt-oss używa zamiast tego low, medium oraz high. Wiele innych rodzin modeli akceptuje jedynie wartość logiczną. Należy przeczytać kartę dla konkretnej pobranej wersji, ponieważ nazwy te nie są standardem. Uruchamianie modelu 27B na serwerze VPS jest priorytetem. Ta strona dotyczy konfiguracji po uzyskaniu odpowiedzi.

Dlaczego wysoki nakład obliczeniowy kosztuje więcej na VPS

Tokeny wyjściowe. Tokeny rozumowania są generowanymi tokenami. Przechodzą one przez tę samą pętlę dekodowania co odpowiedź, z prędkością tokenów na sekundę, na jaką pozwala posiadany sprzęt. Załóżmy, że zadanie generuje 200 tokenów odpowiedzi i 4000 tokenów rozumowania. Wygenerowano 4200 tokenów, a czytelnik zobaczył 200 z nich. Szybkość dekodowania jest określana przez przepustowość pamięci, przez wybraną kwantyzację oraz liczbę wątków: notatki dotyczące optymalizacji llama.cpp ostrzegają, że wartość --threads powyżej liczby fizycznych rdzeni może przeciążyć procesor i spowodować drastyczne spowolnienie generowania. Po dostrojeniu tych parametrów, jedynym pozostałym czynnikiem jest sama liczba tokenów.

Czas rzeczywisty. Użytkownik czeka na pierwszy token odpowiedzi, ponieważ wszystko przed nim to pusty ekran lub animacja ładowania. Rozumowanie jest emitowane jako pierwsze, więc czas oczekiwania to w przybliżeniu liczba tokenów rozumowania podzielona przez szybkość dekodowania, powiększona o czas przetwarzania promptu. Podwojenie długości rozumowania podwaja ten czas oczekiwania.

Kontekst. Tokeny rozumowania zajmują okno kontekstowe tak samo jak każdy inny token. Przy włączonym preserve_thinking, notatnik z pierwszej tury pozostaje w prompcie w piątej turze, więc przetwarzanie promptu staje się wolniejsze z każdą turą, podczas gdy okno zapełnia się z obu stron. Zwiększenie num_ctx w celu jego pomieszczenia zużywa pamięć podręczną KV, która na serwerze VPS bez GPU jest pamięcią RAM systemu, której użytkownik może nie mieć w nadmiarze.

Kiedy zwiększyć poziom, a kiedy pozostawić go na niskim poziomie

Zwiększ poziom w przypadku zadań, w których błędny krok pośredni prowadzi do niepoprawnego wyniku: wieloetapowe obliczenia arytmetyczne i konwersja jednostek, planowanie edycji w wielu plikach, kod wymagający kompilacji oraz problemy z ograniczeniami, gdzie jedna odpowiedź musi spełniać jednocześnie kilka warunków. W takich sytuacjach notatnik wykonuje rzeczywistą pracę, a dłuższy proces myślowy jest tanim sposobem na wykrycie błędu, który model w przeciwnym razie by utrwalił.

Pozostaw poziom na niskim poziomie, gdy odpowiedź znajduje się już w danych wejściowych, a zadanie polega na jej przetworzeniu. Ekstrakcja, klasyfikacja, tagowanie, tłumaczenie, przepisywanie, podsumowywanie i formatowanie należą do tej kategorii. Segment rozumowania w takich przypadkach głównie powtarza zadanie i daje modelowi przestrzeń do odrzucenia poprawnego, pierwszego instynktu.

Pozostaw poziom na niskim poziomie również w przypadku wszelkich zadań interaktywnych. W oknie czatu lub edytorze użytkownik znajduje się w pętli zwrotnej, więc szybka odpowiedź, którą można poprawić, jest lepsza niż wolna, na którą trzeba czekać. To jest rzeczywisty kompromis stojący za skierowaniem agenta programistycznego na model lokalny: agent wykonuje wiele małych wywołań, a koszt rozumowania jest naliczany przy każdym z nich.

Jak ustawić poziom w llama.cpp

llama.cpp zapisuje zmienną bezpośrednio w szablonie, co czyni go środowiskiem uruchomieniowym, w którym można mieć pewność, że poziom został odebrany. Wskaż -m na posiadany plik GGUF.

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf \
  --jinja \
  --reasoning-effort medium \
  --reasoning-format deepseek \
  -c 32768 \
  --host 127.0.0.1 --port 8080

--jinja korzysta z własnego szablonu czatu modelu i jest domyślnie włączone w bieżących kompilacjach. --reasoning-effort akceptuje default, minimal, low, medium, high, xhigh lub max, gdzie default oznacza pozostawienie domyślnego ustawienia szablonu bez zmian. Ta lista jest słownikiem llama.cpp, a nie modelu, dlatego należy przekazywać wyłącznie nazwę wymienioną w karcie: poziom, którego szablon nie definiuje, może wywołać błąd szablonu w momencie żądania. --reasoning-format deepseek przenosi rozumowanie z message.content do message.reasoning_content, co sprawia, że podział jest mierzalny w następnej sekcji.

Aby wyłączyć myślenie zamiast je skracać, ustaw zmienną szablonu samodzielnie:

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf --jinja \
  --chat-template-kwargs '{"enable_thinking": false}'

--reasoning-budget to inny mechanizm. Ogranicza on segment rozumowania w tokenach, przy czym 0 kończy go natychmiast, a -1 pozostawia go bez ograniczeń, zamiast prosić model o zaplanowanie krótszego segmentu. Obie flagi ustawiają wartość domyślną serwera. Według stanu na 2026-10-12, /v1/chat/completions w llama-server przyjmuje również reasoning_effort oraz chat_template_kwargs w treści żądania, przekazując poziom do szablonu dla tego konkretnego wywołania, przy czym none wyłącza rozumowanie. Jeden proces może zatem obsługiwać dwa poziomy wysiłku.

vLLM udostępnia tę samą zmienną dla każdego żądania wewnątrz treści zgodnej z OpenAI:

{"model": "Qwen/Qwen3.8-27B",
 "messages": [{"role": "user", "content": "Summarise this changelog in two lines."}],
 "chat_template_kwargs": {"reasoning_effort": "medium"}}

Ustawianie poziomu w Ollama

Ollama posiada własne pole, think, w /api/chat oraz /api/generate. Akceptuje ono true, false lub nazwę poziomu. Według stanu na 2026-10-12, dla modelu publikującego metadane myślenia, nazwy są specyficzne dla danego modelu: /api/show wyświetla je w sekcji thinking.values wraz z wartością domyślną, a nazwa niewymieniona przez model powoduje powrót do wartości domyślnej bez zgłaszania błędu. Modele bez metadanych korzystają ze starszego, stałego zestawu Ollama: low, medium, high oraz max. Pominięcie think powoduje zastosowanie wartości domyślnej modelu, która dla Qwen3.8 oznacza włączone myślenie.

ollama run qwen3.8:27b --think=low "Draft a one line commit message for a README typo fix"
{"model": "qwen3.8:27b",
 "messages": [{"role": "user", "content": "Which HTTP status code means the request body was too large?"}],
 "think": "low",
 "stream": false}

Proces wnioskowania jest zwracany w message.thinking, a odpowiedź w message.content; dane te są już rozdzielone. Wewnątrz interaktywnej sesji ollama run, polecenia /set think oraz /set nothink przełączają ten stan bez restartu, a /set think low wybiera poziom.

Należy zwrócić uwagę na sytuacje, w których może dojść do cichej awarii. Szablon Qwen3.8 definiuje poziomy low, medium oraz xhigh. Model Ollama zawiera szablon spakowany wewnątrz swojego tagu, zamiast pliku Jinja z oryginalnego repozytorium, a Ollama przekazuje poziom tylko wtedy, gdy spakowany model go wymienia. W pierwszej kolejności należy sprawdzić, co deklaruje dany tag:

curl -s http://localhost:11434/api/show -d '{"model": "qwen3.8:27b"}' | jq .thinking

Nazwa, której nie ma w values, taka jak high lub max dla tego modelu, spowoduje uruchomienie z ustawieniem domyślnym. Nie należy zakładać, że konfiguracja zadziałała. Pomiar czasu trwania operacji zajmuje około minuty.

Jak sprawdzić, czy poziom faktycznie został zastosowany

Wyślij to samo zapytanie na więcej niż jednym poziomie z temperature ustawionym na 0, a następnie porównaj liczbę tokenów. Trzy poniższe nazwy to te, które wymienia karta Qwen3.8; jeśli /api/show podaje inne dla Twojego tagu, użyj tych właściwych. Tutaj jq buduje treść, więc nie trzeba ręcznie uciekać cudzysłowów.

for level in low medium xhigh; do
  body=$(jq -n --arg lvl "$level" '{
    model: "qwen3.8:27b",
    messages: [{role: "user", content: "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take? Answer in minutes."}],
    think: $lvl,
    stream: false,
    options: {temperature: 0, num_ctx: 8192}
  }')
  echo "== $level"
  curl -s http://localhost:11434/api/chat -d "$body" | jq '{
    thinking_chars: (.message.thinking // "" | length),
    answer_chars: (.message.content | length),
    eval_count: .eval_count,
    seconds: (.total_duration / 1e9),
    tok_per_sec: (.eval_count / (.eval_duration / 1e9))
  }'
done

eval_count to każdy wygenerowany token, wliczając w to rozumowanie, więc różnica między dwoma poziomami to niemal w całości proces myślowy. thinking_chars podaje podział bezpośrednio. Dwie rzeczy powinny być prawdziwe: liczby zmieniają się między poziomami, a odpowiedź pozostaje poprawna na niższym z nich. Jeśli eval_count mieści się w granicach szumu statystycznego we wszystkich trzech uruchomieniach, poziom jest ignorowany. Najpierw sprawdź nazwy względem /api/show, ponieważ Ollama uruchamia nielistowaną nazwę jako domyślną; jeśli są zgodne, rozwiązaniem jest środowisko uruchomieniowe, które przekazuje poziom.

Całkowity czas to tylko połowa sukcesu, więc zmierz czas do pierwszego tokena odpowiedzi poprzez strumieniowanie i zatrzymanie na pierwszym niepustym fragmencie content. Wymaga to jq oraz bc.

start=$(date +%s.%N)
curl -sN http://localhost:11434/api/chat -d '{
  "model": "qwen3.8:27b",
  "messages": [{"role": "user", "content": "Explain what a reverse proxy does, in three sentences."}],
  "think": "low",
  "stream": true
}' |
while IFS= read -r line; do
  if [ -n "$(printf '%s' "$line" | jq -r '.message.content // ""')" ]; then
    echo "first answer token after $(echo "$(date +%s.%N) - $start" | bc)s"
    break
  fi
done

Uruchom to na low, a następnie ponownie na xhigh. Różnica to czas oczekiwania, który kupujesz. W llama.cpp te same liczby wracają wewnątrz odpowiedzi, bez konieczności wykonywania obliczeń w powłoce:

curl -s http://localhost:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "local", "temperature": 0,
       "messages": [{"role": "user", "content": "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take?"}]}' | jq '{
  reasoning_chars: (.choices[0].message.reasoning_content // "" | length),
  answer_chars: (.choices[0].message.content | length),
  predicted_n: .timings.predicted_n,
  tok_per_sec: .timings.predicted_per_second
}'

Wykonaj to na własnej maszynie. Opublikowane porównanie wysiłku zostało zmierzone na sprzęcie, który nie jest Twój, a Twój współczynnik dekodowania to parametr, który zamienia liczbę tokenów na sekundy. Pomiar tokenów na sekundę na własnym serwerze dostarcza tego parametru: tokeny rozumowania podzielone przez Twój współczynnik dekodowania to czas oczekiwania, który właśnie dodałeś.

Co może pójść nie tak

Odpowiedź jest ucięta lub content jest puste, podczas gdy thinking jest pełne. Limit generowania został wyczerpany przez proces wnioskowania. Parametr num_predict w Ollama ogranicza całkowitą długość generowania, wliczając w to wnioskowanie, a ponieważ wnioskowanie odbywa się w pierwszej kolejności, limit 512 tokenów przy wysokim poziomie wysiłku może zakończyć odpowiedź przed wygenerowaniem właściwej treści. Ollama zgłasza "done_reason": "length" dla takiej odpowiedzi. Należy zwiększyć limit lub obniżyć poziom wysiłku. Jak num_predict zlicza tokeny szczegółowo opisuje tę zależność.

Zmiana poziomu nie przynosi efektów. Liczba tokenów jest identyczna na każdym poziomie. Oznacza to, że środowisko uruchomieniowe nie przekazuje zmiennej, szablon jej nie odczytuje lub w przypadku Ollama nazwa nie znajduje się na liście obsługiwanych tagów i nastąpiło przywrócenie wartości domyślnej. Należy sprawdzić szablon faktycznie używany przez środowisko uruchomieniowe, zamiast tego z oryginalnego repozytorium. Narzędzie llama.cpp z parametrami --jinja oraz --chat-template-kwargs wpisuje zmienną ręcznie, co stanowi dobry punkt odniesienia: jeśli poziom działa w tym przypadku, a w innych nie, oznacza to, że model jest poprawny, a problem leży po stronie środowiska uruchomieniowego, które odrzuca zmienną.

Nazwa poziomu jest odrzucana. Błąd szablonu w momencie żądania lub awaria przy pierwszej wiadomości na poprawnie działającym serwerze zazwyczaj oznacza przekazanie poziomu, który nie został zdefiniowany w szablonie, na przykład high dla modelu, którego karta zawiera tylko low, medium oraz xhigh. W Ollama model bez metadanych dotyczących myślenia akceptuje tylko low, medium, high oraz max, a każda inna wartość zwraca błąd invalid think value.

Wielokrotne tury czatu spowalniają każdą kolejną odpowiedź. Stare wnioskowanie jest przechowywane w historii. Należy ustawić preserve_thinking na false, jeśli model to obsługuje, lub usunąć pole thinking z wiadomości wysyłanych zwrotnie. W przeciwnym razie czas przetwarzania promptu rośnie z każdą turą, mimo że długość odpowiedzi pozostaje taka sama.

Jakość spada przy niskim poziomie wysiłku w zadaniu uznanym za proste. Niektóre operacje ekstrakcji nie są w rzeczywistości ekstrakcją. Jeśli dane wejściowe wymagają konwersji jednostek lub zastosowania reguł w określonej kolejności, jest to zadanie wymagające wnioskowania, nawet jeśli wynik jest krótki. W takim przypadku należy zwiększyć poziom dla pojedynczego wywołania, zamiast zmieniać go dla całego serwera.

Uruchamianie dwóch poziomów jednocześnie

llama.cpp ustawia domyślny poziom przy starcie za pomocą --reasoning-effort, jednak bieżące kompilacje obsługują również reasoning_effort dla każdego żądania. Dzięki temu jeden proces i jedna kopia wag mogą obsługiwać edytor na niskim poziomie oraz nocne zadanie wsadowe na wyższym poziomie. Jeśli preferowane jest przypisanie poziomu na stałe przy starcie, można uruchomić dwa procesy na dwóch portach. Wiąże się to jednak z kosztem dwóch kopii wag w pamięci, chyba że zadania zostaną rozdzielone w czasie. W obu przypadkach zadania współdzielą wydajność dekodowania jednej maszyny. Na pojedynczym VPS najtańszym rozwiązaniem jest zazwyczaj niski wysiłek dla zadań interaktywnych oraz zaplanowane zadanie o wyższym wysiłku dla pracy, która nie wymaga nadzoru. Zasada Co się dzieje, gdy kilku użytkowników współdzieli jeden lokalny model ma tutaj zastosowanie: tokeny rozumowania stanowią obciążenie dekodowaniem, więc zwiększenie wysiłku redukuje efektywną współbieżność w przybliżeniu o ten sam współczynnik, o jaki wzrasta liczba tokenów.

FAQ

Jakiego poziomu wysiłku wnioskowania należy używać domyślnie?

Należy zacząć od najniższego dostępnego poziomu i zwiększać go tylko w przypadku zadań, które zakończyły się niepowodzeniem. Wiele modeli wnioskujących ma ustawiony wysoki poziom domyślny, a Qwen3.8-27B od października 2026 roku domyślnie korzysta z xhigh, czyli najwyższego poziomu. Ustawienie to wybrano, aby uzyskać lepsze wyniki w tabelach benchmarkowych, a tabele te nie uwzględniają kosztu czasu. Na własnym sprzęcie płacisz czasem w sekundach, dlatego wyższy poziom powinien być wybierany świadomie dla konkretnego zadania, a nie jako ustawienie dziedziczone przez każde zapytanie.

Czy tokeny wnioskowania wliczają się do okna kontekstowego?

Tak. Są to zwykłe tokeny w wyjściu, które zajmują miejsce w oknie kontekstowym wraz z resztą danych. To, czy pozostaną tam w kolejnej turze, zależy od środowiska uruchomieniowego i modelu. Dokumentacja Qwen3.8 opisuje preserve_thinking, włączone domyślnie, które zachowuje wcześniejsze wnioskowanie w historii, więc długa konwersacja przechowuje każdy wygenerowany brudnopis. Ustawienie tej wartości na false lub usunięcie pola thinking z przesyłanych wiadomości spowoduje, że przetwarzanie promptu przestanie rosnąć.

Dlaczego zmiana poziomu wnioskowania nie wpływa na liczbę tokenów?

Ustawienie nie dociera do szablonu czatu. Poziom jest zmienną szablonu, więc działa tylko wtedy, gdy środowisko uruchomieniowe ją przekazuje, a dołączony szablon ją odczytuje. Niektóre środowiska uruchomieniowe dostarczają własny szablon zamiast pliku Jinja z oryginalnego repozytorium, przez co zmienna jest pomijana bez wyświetlania błędu. Ollama również uruchamia nazwę poziomu, której model nie wymienia w swoich ustawieniach domyślnych, również bez zgłaszania błędu. Można to zweryfikować, wysyłając ten sam prompt na najniższym i najwyższym poziomie z temperature ustawionym na 0 i porównując eval_count. Jeśli liczby są zbliżone w granicach błędu statystycznego, poziom jest ignorowany.

Czy mniejszy wysiłek wnioskowania obniża dokładność modelu?

Zależy to od zadania i warto to zmierzyć, zamiast zakładać z góry. W przypadku zadań, gdzie odpowiedź znajduje się już w danych wejściowych, takich jak ekstrakcja lub przepisywanie tekstu, krótszy brudnopis zazwyczaj nic nie zmienia. Tam, gdzie krok pośredni musi być poprawny przed wykonaniem kolejnego, na przykład w wieloetapowych obliczeniach matematycznych lub kodzie, który musi się skompilować, dokładność spada wraz ze skróceniem brudnopisu. Należy przygotować zestaw dwudziestu promptów z rzeczywistego obciążenia, uruchomić je na dwóch poziomach z temperature ustawionym na 0 i policzyć błędne odpowiedzi. Ta liczba jest specyficzna dla danego obciążenia i żadna opublikowana tabela jej nie poda.

Czy ten artykuł był przydatny?