ChatGPT e le LLM (Part 2)

[Tsunetomo]

Sennò vai a finire come i deliri di cosmologia che abbiamo già visto in questi lidi.

La radice del problema è che l’output delle LLM è verosimile. Ma c’è una bella differenza tra verosimile e vero; e un conto è se ci giochi per intrattenimento, un conto se finisci a far danni in azienda per via di analisi fuorvianti.

[gigawat (ma io che cazzo ne so scusa)]

@Tsunetomo

Sennò vai a finire come i deliri di cosmologia che abbiamo già visto in questi lidi.

[Tsunetomo]

Detto questo, come study buddy, tutor o per scoprire nomi di algoritmi utili o in quale libreria software si potrebbe annidare la funzionalità che fa al caso tuo (su domanda molto precisa) sono già estremamente utili.

[LorenzoLamas]

Un altro consiglio è non riprendere sempre dall’ultima chatta che se l’avete convinto con una stronzata continuerà a riproporvela

Su un idea o una soluzione potete chiedergli di analizzarla con un prompt del tipo.

critica l’idea che ti ho proposto/soluzione che mi hai proposto tramite un GAN Style thinking

Il risultato sarà una confutatio socratica che potrebbe evidenziare carenze, punti deboli, scelte errate a cui non avevate pensato o semplicemente la LLM vi aveva convinto che fossero quelle giuste

[Ficus]

Anthropic investigates report of rogue access to hack-enabling Mythos AI

Non so se andava messo qui o nel thread della cybersecurity

Phortino sto mythos comunque, si spaccia per l’uber pro della cybersecurity pericolosissimo e poi si fa hackerare

[LorenzoLamas]

intanto hanno levato Claude Code dagli account Pro mi sa che stanno stanno sterzando verso chi ha le tasche piene: aziende, medie/piccole imprese, freelance ecc. insomma chi può spendere, evitando di correre dietro alla fascia dei 20$ che è bella satura con Gemini/OpenAI e i vari modelli cinesi che ormai propongono abbonamenti a quel prezzo.

P.S.

Qwen ha rilasciato il 3.6 da 27b denso

Qwen Studio

[Teocrazia]

in realtà pare sia un test su alcuni, anche se son dell’idea che sul lungo periodo ridurranno sempre di più i piani bassi

[Tsunetomo]

@LorenzoLamas

Qwen ha rilasciato il 3.6 da 27b denso

aspetto a vedere i benchmark quando le quantizzazioni si stabilizzano, non ho un cazzo di voglia di scavare tra la merda di centinaia di post tipo “è un gamechanger” e poi scopri che hanno semplicemente incluso il pellicano del cazzo sulla bici nel training.

[LorenzoLamas]

@Tsunetomo

aspetto a vedere i benchmark quando le quantizzazioni si stabilizzano, non ho un cazzo di voglia di scavare tra la merda di centinaia di post tipo “è un gamechanger” e poi scopri che hanno semplicemente incluso il pellicano del cazzo sulla bici nel training.

Ho appena provato Qwen3.6 27B-IQ3_XXS di unsloth anche perché non è che ho molte alternative con un modello denso e solo 16GB di VRAM. L’ho ottimizzato il più possibile abilitando quantizzazioni a 4bit pure sulla KV cache e al massimo riesco a impostarlo a 64k di contesto con 16GB pieni.

A funzionare funziona come la 35B ai vari prompt di test che gli ho dato è sugli stessi livelli solo che va 25-30tok/s ( anche dimezzando il context non va più di così ) rispetto ai 60-70tok/s della 35B la nota positiva che ne posso subito trarre è che un quantizzazione così spinta non sembra averlo rincoglionito, poi se è superiore alla 35B lo si potrà appurare alla lunga su più task ma di certo non lo potrò dire io che sono troppo al limite.

Nell’ultima settimana ho usato massicciamente Qwen3.6 35B-A3B-IQ3_XXS vedendo veramente pochi errori e ho fatto anche un tentativo verso il basso come la IQ2_XXS che per 1GB in meno in uso agentico parte subito a fare errori, cazzate varie e si blocca senza motivo.

[gigawat (ma io che cazzo ne so scusa)]

Lamas riesci a quantizzare 30 tok al secondo in qualche task semplice a quanto tempo corrisponderebbero?
Sto leggendo un po’ sul sito di unsloth intanto

[LorenzoLamas]

Quella è una misura indicativa perché quando si riempie il contesto diventano pure 20tok/s se non peggio perché con la VRAM sono veramente al limite e può capitare che inizi a rallentare tutto.

Con l’attuale setup di LM Studio non lo userei, perché è votato alla faciltià d’utilizzo e non al massimo dell’ottimizzazione in questo momento il 27B è un modello per chi ha 20GB di VRAM in su

A livello di usabilità preferisco i 60-70tok/s della 35B sono un bel risultato sopratutto perché hai anche un PC perfettamnete usabile con quasi un 1GB di VRAM libero e mentre frulla l’agente col thinking ed il file edinting puoi quantomeno usare il browser, usare altre app non GPU intensive a livello di consumi la 4080 di picco fa 200w al massimi con una media di 150w sui 320w di TDP.

Per fare un esempio col prompt spec diven della pallina che rimbalza nell’esangono rotante

Write a complete Python program that simulates a ball bouncing inside a rotating hexagon.

PHYSICS ENGINE:

• Gravity: 500 pixels/s² downward
• Ball velocity updates each frame: vel.y += gravity * dt
• Position updates: pos += vel * dt

COLLISION DETECTION (CRITICAL):

• Work directly in world space, do NOT use coordinate transformations
• For each of the 6 hexagon edges (as line segments):
  1. Find closest point on segment to ball center
  2. Calculate distance from ball center to closest point
  3. If distance < ball_radius: collision detected

COLLISION RESPONSE:

• Calculate normal vector: from closest point toward ball center, normalized
• Push ball out: ball.pos += normal * penetration_depth
• Decompose velocity into normal and tangential components
• Reflect normal component: v_normal = -v_normal
• Apply friction to tangential: v_tangential *= 0.8
• Recombine: new_velocity = v_normal + v_tangential

HEXAGON ROTATION:

• Store current angle in radians
• Each frame: angle += rotation_speed * dt
• Recalculate all 6 vertices based on current angle
• Vertices formula: (cx + rcos(60°i + angle), cy + rsin(60°i + angle))

RENDERING (pygame):

• 800x600 window, 60 FPS
• Draw hexagon as polygon outline
• Draw ball as filled circle
• Clear screen each frame

CODE STRUCTURE:

• Use simple tuples for 2D vectors
• Helper functions: dot product, vector subtraction, normalization
• Single file, all imports at top
• NO testing code, NO main guard
• Ready to run directly

EDGE CASE HANDLING:

• Before calculating penetration_depth, check if dist == 0
• If dist == 0 (ball center exactly on edge):
  • Set normal to perpendicular of edge pointing inward
  • Calculate as: edge_perpendicular = (-edge.y, edge.x) normalized
  • Determine inward direction using hexagon center
  • Set penetration_depth = BALL_RADIUS (full radius)
• This prevents division by zero in normalize(dist_vec)

The key is: calculate collisions using the hexagon’s current rotated vertices
directly, without any coordinate system transformations.

ci ha pensato su 1 minuto e 32 secondi e poi ha prodotto

import pygame
import math
import sys

Constants

WIDTH, HEIGHT = 800, 600
GRAVITY = 500.0
BALL_RADIUS = 15.0
HEX_CENTER = (WIDTH // 2, HEIGHT // 2)
HEX_RADIUS = 200.0
ROTATION_SPEED = math.pi / 4  # radians/sec

Vector helpers (tuples)

def vec_sub(a, b): return (a[0] - b[0], a[1] - b[1])
def vec_add(a, b): return (a[0] + b[0], a[1] + b[1])
def vec_scale(v, s): return (v[0] * s, v[1] * s)
def vec_dot(a, b): return a[0]*b[0] + a[1]*b[1]
def vec_len_sq(v): return v[0]**2 + v[1]**2
def vec_len(v): return math.sqrt(vec_len_sq(v))
def normalize(v):
l = vec_len(v)
if l < 1e-9: return (0.0, 0.0)
return (v[0]/l, v[1]/l)

Initial state

ball_pos = (WIDTH//2, HEIGHT//3)
ball_vel = (50.0, -200.0)

pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()

angle = 0.0  # radians

while True:
dt = clock.tick(60) / 1000.0
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()

# Update hexagon rotation
angle += ROTATION_SPEED * dt

# Recalculate vertices each frame using world space formula
verts = []
for i in range(6):
    rad_angle = (math.pi / 3) * i + angle
    vx = HEX_CENTER[0] + HEX_RADIUS * math.cos(rad_angle)
    vy = HEX_CENTER[1] + HEX_RADIUS * math.sin(rad_angle)
    verts.append((vx, vy))

# Physics integration
ball_vel = (ball_vel[0], ball_vel[1] + GRAVITY * dt)
ball_pos = vec_add(ball_pos, vec_scale(ball_vel, dt))

# Collision detection & response
for i in range(6):
    A = verts[i]
    B = verts[(i + 1) % 6]
    edge_vec = vec_sub(B, A)
    AP = vec_sub(ball_pos, A)

    ab_sq = vec_dot(edge_vec, edge_vec)
    if ab_sq == 0: continue

    t = max(0.0, min(1.0, vec_dot(AP, edge_vec) / ab_sq))
    closest = vec_add(A, vec_scale(edge_vec, t))
    dist_vec = vec_sub(ball_pos, closest)
    dist = vec_len(dist_vec)

    if dist < BALL_RADIUS:
        # Edge case handling (prevents division by zero in normalize)
        if dist < 1e-9:  # Treats exact zero as degenerate edge contact
            edge_perp = (-edge_vec[1], edge_vec[0])
            normal = normalize(edge_perp)
            # Determine inward direction using hexagon center
            mid_point = vec_add(A, vec_scale(edge_vec, 0.5))
            to_center = vec_sub(HEX_CENTER, mid_point)
            if vec_dot(normal, to_center) < 0:
                normal = (-normal[0], -normal[1])
            penetration_depth = BALL_RADIUS
        else:
            normal = normalize(dist_vec)
            penetration_depth = BALL_RADIUS - dist

        # Push ball out
        ball_pos = vec_add(ball_pos, vec_scale(normal, penetration_depth))

        # Velocity decomposition & response
        vn_scalar = vec_dot(ball_vel, normal)
        v_normal_vec = vec_scale(normal, vn_scalar)
        v_tangential_vec = vec_sub(ball_vel, v_normal_vec)

        new_vn = vec_scale(v_normal_vec, -1.0)
        new_vt = vec_scale(v_tangential_vec, 0.8)
        ball_vel = vec_add(new_vn, new_vt)

# Rendering
screen.fill((30, 30, 30))
pygame.draw.polygon(screen, (255, 255, 255), verts, width=3)
pygame.draw.circle(screen, (255, 100, 100), 
                   (int(ball_pos[0]), int(ball_pos[1])), int(BALL_RADIUS))
pygame.display.flip()

ci ha impiegato totalmente 1 minuto e 48 secondi girando a 65tok/s per un totale di 7077 tokens generati incluso il thinking

[LorenzoLamas]

Anthropic conferma tutte le ipotesi da bar sport sul calo delle performance: Hanno abbassato il resoning su medium per ridurre le latenze dovute ai sovraccarichi, per ottimizzare il caching hanno causato il bug che lo faceva sparire in 5 minuti con enorme spreco di token e per ridurre la verbosità di opus 4.7 che consumava troppo token l’hanno rincoglionito

An update on recent Claude Code quality reports

P.S.

Intanto ho testato llama.cpp in versione server fuori da LM Studio praticamente usando quella che mi ha installato Unsloth Studio con una serie di flag ultra ottimizzati per la mia configurazione ora vado a 110 tok/s con Qwen3.6-35B-A3B@IQ3_XXS con 200k di contesto e occupazione della VRAM a nel range 15.2-15.8 GB a contesto pieno

[Tsunetomo]

racconta questi flags…

[LorenzoLamas]

Domani posto tutto spiegando per filo e per segno ho già i file pronti sul PC ma su AMD non so quanto possa spremere in più.

Nel mio caso il collo di bottiglia della 4080 è far entrare tutto in VRAM ed evitare l’offload del layer sulla CPU è per quello che vola letteralmente, comunque sui modelli 4bit sono passato da 40 a 60 tok/s e sul 27B@IQ3_XXS dai 25-30 a 40 tok/s solidi con 131k di contesto.

Per AMD indagherò meglio sul laptop dove ho Ryzen AI 7 350 con 32 GB di memoria unificata, GPU/NPU con ROCm e Vulkan

[Nightmare]

ha confermato pure di togliere Claude code dal pro

Confirmed that Anthropic - as of now - has removed Claude Code from new Pro signups. This is what the pricing page looks like.

Feels like Anthropic has the bet that those doing coding work will be willing and ready to pay at least $100/month, going forward.

For clarity, we’re running a small test on ~2% of new prosumer signups. Existing Pro and Max subscribers aren’t affected.

[LorenzoLamas]

E OpenAI presenta GPT-5.5

https://openai.com/index/introducing-gpt-5-5/

[LorenzoLamas]

@Tsunetomo

racconta questi flags…

Ieri ho dimenticato di menzionare che ero col settaggio al risparmio energetico per cui i token al secondo sarebbero 150

ho posto in questo repo il .bat con le info essenziali poi per chiarimenti basta chiedere

GitHub - taphost/llamabat: un semplice batch per llama.cpp

P.S.

Ora va

[Tsunetomo]

404

[LorenzoLamas]

Preview di DeepSeek V4 va quanto Opus ma è 1.6T di parametri

DeepSeek V4 Preview Release | DeepSeek API Docs

[starship]

Screenshot-24-4-2026-21378-grok-com.jpg (778×800)

e non ho usato nessun prompt strano e nessun trucco, ma solo insistito che volevo una cosa più volte fino alla bestemmia finale…