Mikä tekoälymalli on parempi koodauksessa , mekaniikassa ja algoritmisessa tarkkuudessa – mikä malli tarjoaa todellisen tarkkuuden?

Yhdysvaltain varakkaat teknologiajättiläiset hallitsivat aikoinaan tekoälymarkkinoita, mutta DeepSeekin julkaisu aiheutti alalla aaltoja, mikä herätti valtavaa hypeä. Kuitenkin, ikään kuin tämä ei olisi tarpeeksi, Qwen 2.5 syntyi - ohitti DeepSeekin useilla alueilla. Kuten muutkin päättelymallit, kuten DeepSeek-R1 ja OpenAI:n O1, Qwen 2.5-Max toimii tavalla, joka kätkee sen ajatteluprosessin, mikä vaikeuttaa sen päätöksentekologiikan jäljittämistä.

Tässä artikkelissa ChatGPT, Qwen ja DeepSeek käydään läpi joukon tärkeitä haasteita, jotka vaihtelevat laskentaongelmien ratkaisemisesta koodin virheenkorjaukseen . Olitpa täydellistä tekoälyn koodausassistenttia etsivä kehittäjä , kvanttimekaniikkaa käsittelevä tutkija tai yritysammattilainen , yritän tänään paljastaa, mikä malli on älykkäin valinta tarpeisiisi (ja budjettiisi)

Tekoälymallin ominaisuuksien vertaileva analyysi: -

1. Chatgpt

OpenAI:n kehittämä ChatGPT on edelleen hallitseva voima tekoälyavaruudessa. Se on rakennettu tehokkaalle GPT-5-arkkitehtuurille ja hienosäädetty käyttämällä RLHF ( Reforcement Learning from Human Feedback) -tekniikkaa. Se on luotettava työkalu monenlaisiin tehtäviin luovasta kirjoittamisesta tekniseen dokumentointiin, joten se on paras valinta sisällöntuottajille, kouluttajille ja startup-yrityksille. Se ei kuitenkaan ole täydellinen. Kun kyse on erikoisaloista, kuten edistyneestä matematiikasta tai kapea-alaisista juridisista aloista, se voi kamppailla. Lisäksi sen korkeat infrastruktuurikustannukset tekevät pienten yritysten tai yksittäisten kehittäjien vaikeaksi käyttää sitä helposti

ChatGPT, joka on rakennettu 3 miljardin dollarin + sijoituksella, on massiivinen infrastruktuurimalli, kun taas DeepSeek saavutti vastaavan suorituskyvyn vain 5,6 miljoonalla dollarilla – klassinen Kiinan hetki, vai mitä?

2. Syvähaku

DeepSeek nousi tyhjästä pimeänä hevosena tekoälykilpailussa, joka haastaa vakiintuneet jättiläiset keskittyen laskennalliseen tarkkuuteen ja tehokkuuteen.

Toisin kuin sen kilpailijat, se on räätälöity tieteellisiin ja matemaattisiin tehtäviin, ja se on koulutettu huipputietosarjoihin, kuten arXiv ja Wolfram Alph a, mikä auttaa sitä suoriutumaan hyvin sellaisilla aloilla kuin optimointi, fysiikan simulaatiot ja monimutkaiset matemaattiset ongelmat . DeepSeekin todellinen vahvuus on sen halpa (ei kiinalaista sanailua 😤). Vaikka ChatGPT:n ja Qwenin kaltaiset mallit vaativat valtavia resursseja, Deepseek tekee työn huomattavasti pienemmillä kustannuksilla. Joten kyllä sinun ei tarvitse saada 1000 dollaria ChatGPT-tilauksesta

DeepSeekin tapa reagoida tuntuu hieman robottiselta, eikä se mukaudu hyvin tehtäviin, jotka eivät ole liian teknisiä. Se sopii erinomaisesti tietyille aloille, kuten matematiikalle ja tutkimukselle, mutta ei satunnaiseen tai luovaan keskusteluun

3. Qwen

Kuka olisi Deepseekin jälkeen uskonut, että toinen kiinalainen tekoäly ponnahtaa esiin ja ottaisi vallan? Klassinen Kiinan liike – levitä jotain ja tällä kertaa se on AI lol

Qwen hallitsee bisnespeliä monikielisellä kokoonpanollaan ja loistaa Aasian kaltaisissa paikoissa, erityisesti mandariinikiinan ja arabian kielellä. Se on tarkoitettu lainopillisiin ja taloudellisiin tehtäviin, eikä se ole DeepSeek R1:n kaltainen päättelymalli, mikä tarkoittaa, että et näe sen ajatteluprosessia. Mutta aivan kuten DeepSeekissä, siinä on robottitunnelma, mikä tekee siitä vähemmän hauskaa arki- tai luovassa työssä. Jos haluat jotain joustavampaa, Qwen ei ehkä ole paras ripustus

Voit ajatella sitä kuin asiantuntijaryhmä: jos kysyt monimutkaisen kysymyksen fysiikasta, vain fysiikan asiantuntijat vastaavat, kun taas muu tiimi pysyy passiivisena.

Testausaika: Kolmen tekoälyn vertaaminen todellisiin ongelmiin

Oikeudenmukaisuuden ja arvioinnin takaamiseksi heitetään joitain eniten hypettyjä haasteita, kuten vaikeita matemaattisia tehtäviä, villiä fysiikkaa, koodaustehtäviä ja hankalia tosielämän kysymyksiä.

— — — — — — — — — — — —

1. Fysiikka: Pyörivän pallon ongelma

Asioiden käynnistämiseksi sukeltakaamme klassiseen "pyörivä pallo laatikossa" -ongelmaan, josta on tullut suosittu vertailukohta testattaessa, kuinka hyvin eri tekoälymallit selviävät monimutkaisista tehtävistä

Haaste : Simuloi pyörivän laatikon sisällä pomppivaa palloa fysiikan lakeja noudattaen

Kuvittele avaruudessa pyörivä 2d-muoto. Sisällä pallo pomppii seinistä pysyen rajojen sisällä ilman ulkoista voimaa. Ensi silmäyksellä se saattaa vaikuttaa yksinkertaiselta , mutta painovoiman, jatkuvan pyörimisen ja tarkan törmäysdynamiikan huomioon ottaminen tekee siitä haastavan simulaation. Yllätyt kuinka eri tavalla tekoälymallit käsittelevät sitä

Kehotus: -

 Write a Python script that simulates a yellow ball bouncing inside a rotating square. The ball should bounce realistically off the square's edges, with the square rotating slowly over time The ball must stay within the square's boundaries as the box rotates. Box Rotation: The box should rotate continuously. Ball Physics: The ball reacts to gravity and bounces off the box's walls. Ball Inside Boundaries: Make sure the ball doesn't escape the box's boundaries, even as the box rotates. Realistic Physics: Include proper collision detection and smooth animation Use Python 3.x with Pygame or any similar library for rendering

Tulokset:

1. ChatGPT:n tulos: Nopea mutta virheellinen

Chatgpt:n suhteen minulla oli korkeat odotukset. Mutta tulokset? Sanotaanpa vain, että ne olivat... alivoimaisia. Vaikka DeepSeek käytti aikaa tarkkuuteen, ChatGPT sylki heti puhtaan näköisen käsikirjoituksen. Pallo ei pomppinut realistisesti. Sen sijaan se häiritsi laatikon reunojen ympärillä , joskus juuttuen kulmiin tai asteittain seinien läpi. On selvää, että ChatGPT suosii nopeutta syvyyden sijaan ja tarjoaa toimivan ratkaisun – mutta vain alkeellisimmassa mielessä

Chatgpt:n koodi:

 import pygame import math # Initialize Pygame pygame.init() # Constants WIDTH, HEIGHT = 600, 600 FPS = 60 GRAVITY = 0.2 BOUNCE_DAMPING = 0.8 ROTATION_SPEED = 0.5 # Degrees per frame BALL_RADIUS = 10 # Colors YELLOW = (255, 255, 0) WHITE = (255, 255, 255) BLACK = (0, 0, 0) # Screen setup screen = pygame.display.set_mode((WIDTH, HEIGHT)) clock = pygame.time.Clock() # Square properties square_center = (WIDTH // 2, HEIGHT // 2) square_size = 300 angle = 0 # Ball properties ball_pos = [WIDTH // 2, HEIGHT // 2 - 50] ball_velocity = [2, 0] # Function to rotate a point around a center def rotate_point(point, center, angle): x, y = point cx, cy = center radians = math.radians(angle) cos_a, sin_a = math.cos(radians), math.sin(radians) new_x = cos_a * (x - cx) - sin_a * (y - cy) + cx new_y = sin_a * (x - cx) + cos_a * (y - cy) + cy return new_x, new_y # Main loop running = True while running: screen.fill(BLACK) for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # Apply gravity ball_velocity[1] += GRAVITY # Move ball ball_pos[0] += ball_velocity[0] ball_pos[1] += ball_velocity[1] # Compute rotated square corners half_size = square_size // 2 square_corners = [ (-half_size, -half_size), (half_size, -half_size), (half_size, half_size), (-half_size, half_size) ] rotated_corners = [rotate_point((square_center[0] + x, square_center[1] + y), square_center, angle) for x, y in square_corners] # Check for collisions for i in range(4): p1, p2 = rotated_corners[i], rotated_corners[(i + 1) % 4] dx, dy = p2[0] - p1[0], p2[1] - p1[1] length = math.hypot(dx, dy) normal = (-dy / length, dx / length) # Perpendicular normal # Distance from ball to edge projection = (ball_pos[0] - p1[0]) * normal[0] + (ball_pos[1] - p1[1]) * normal[1] if projection < BALL_RADIUS: # Ball is colliding with edge # Reflect velocity dot = ball_velocity[0] * normal[0] + ball_velocity[1] * normal[1] ball_velocity[0] -= 2 * dot * normal[0] ball_velocity[1] -= 2 * dot * normal[1] # Apply bounce damping ball_velocity[0] *= BOUNCE_DAMPING ball_velocity[1] *= BOUNCE_DAMPING # Move ball out of collision ball_pos[0] += normal[0] * (BALL_RADIUS - projection) ball_pos[1] += normal[1] * (BALL_RADIUS - projection) # Rotate square angle += ROTATION_SPEED # Draw rotated square pygame.draw.polygon(screen, WHITE, rotated_corners, 2) # Draw ball pygame.draw.circle(screen, YELLOW, (int(ball_pos[0]), int(ball_pos[1])), BALL_RADIUS) # Update display pygame.display.flip() clock.tick(FPS) pygame.quit()

Lähtö:

2. Syvähaku

DeepSeekin tuotos sai minut todella hämmästymään. Vaikka ChatGPT oli nopea luomaan koodia, DeepSeek vei 200 sekuntia vain miettimään ongelmaa. DeepSeek ei vain kirjoittanut toimivaa käsikirjoitusta ; se loi erittäin optimoidun, fysiikan tarkan simulaation , joka käsitteli jokaisen reunakotelon virheettömästi

DeepSeekin koodi:

 import pygame import math # Initialize Pygame pygame.init() # Constants WIDTH, HEIGHT = 600, 600 SQUARE_SIZE = 400 SQUARE_HALF = SQUARE_SIZE // 2 BALL_RADIUS = 10 GRAVITY = 0.5 RESTITUTION = 0.8 ANGULAR_VELOCITY = 1 # Degrees per frame # Setup display screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Bouncing Ball in Rotating Square") clock = pygame.time.Clock() # Initialize variables square_center = (WIDTH//2, HEIGHT//2) angle = 0 ball_pos = [WIDTH//2, HEIGHT//2] ball_vel = [0, 0] def rotate_point(point, center, angle): """Rotate a point around a center by given angle (degrees)""" theta = math.radians(-angle) ox, oy = center px, py = point qx = ox + math.cos(theta) * (px - ox) - math.sin(theta) * (py - oy) qy = oy + math.sin(theta) * (px - ox) + math.cos(theta) * (py - oy) return qx, qy running = True while running: dt = clock.tick(60) / 1000 # Delta time in seconds # Event handling for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # Update square rotation angle = (angle + ANGULAR_VELOCITY) % 360 # Apply physics ball_vel[1] += GRAVITY ball_pos[0] += ball_vel[0] * dt ball_pos[1] += ball_vel[1] * dt # Collision detection and response # Convert ball position to square's local coordinate system translated = (ball_pos[0] - square_center[0], ball_pos[1] - square_center[1]) rotated = rotate_point((translated[0], translated[1]), (0, 0), -angle) collision = False new_local_x, new_local_y = rotated[0], rotated[1] # Check boundaries in local coordinates if rotated[0] < -SQUARE_HALF + BALL_RADIUS: new_local_x = -SQUARE_HALF + BALL_RADIUS collision = True elif rotated[0] > SQUARE_HALF - BALL_RADIUS: new_local_x = SQUARE_HALF - BALL_RADIUS collision = True if rotated[1] < -SQUARE_HALF + BALL_RADIUS: new_local_y = -SQUARE_HALF + BALL_RADIUS collision = True elif rotated[1] > SQUARE_HALF - BALL_RADIUS: new_local_y = SQUARE_HALF - BALL_RADIUS collision = True if collision: # Convert corrected position back to global coordinates corrected = rotate_point((new_local_x, new_local_y), (0, 0), angle) ball_pos[0] = corrected[0] + square_center[0] ball_pos[1] = corrected[1] + square_center[1] # Calculate reflection in local coordinates local_vel = rotate_point(ball_vel, (0, 0), -angle) if new_local_x != rotated[0]: # X-axis collision local_vel = (-local_vel[0] * RESTITUTION, local_vel[1]) if new_local_y != rotated[1]: # Y-axis collision local_vel = (local_vel[0], -local_vel[1] * RESTITUTION) # Convert velocity back to global coordinates global_vel = rotate_point(local_vel, (0, 0), angle) ball_vel[0], ball_vel[1] = global_vel[0], global_vel[1] # Drawing screen.fill((0, 0, 0)) # Draw rotating square square = pygame.Surface((SQUARE_SIZE, SQUARE_SIZE), pygame.SRCALPHA) pygame.draw.rect(square, (255, 0, 0), (0, 0, SQUARE_SIZE, SQUARE_SIZE), 2) rotated_square = pygame.transform.rotate(square, angle) screen.blit(rotated_square, rotated_square.get_rect(center=square_center)) # Draw ball pygame.draw.circle(screen, (255, 255, 0), (int(ball_pos[0]), int(ball_pos[1])), BALL_RADIUS) pygame.display.flip() pygame.quit()

Lähtö:

3. Qwenin tulos: Pettymys yritys

Jos ChatGPT:n tulos oli ylivoimainen, Qwen oli suorastaan pettymys . Koska Qwenilla on vahva maine monimutkaisten tehtävien hoitajana, minulla oli todella korkeat odotukset sen suorituskyvystä. Mutta kun suoritin sen koodin pyörivän pallon simulaatiolle, tulokset olivat kaukana odotuksistani . ChatGPT:n tavoin Qwen loi koodin lähes välittömästi – ei syvällistä ajattelua.

Pallo oli laatikon ulkopuolella suurimman osan simulaatiosta, täysin uhmaten fysiikan lakeja. Itse laatikko oli puoliksi kehyksessä , joten vain osa siitä näkyi kankaalla

Qwenin koodi

 import pygame import math # Initialize Pygame pygame.init() # Screen dimensions WIDTH, HEIGHT = 600, 600 screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Bouncing Ball in Rotating Square") # Colors YELLOW = (255, 255, 0) WHITE = (255, 255, 255) BLACK = (0, 0, 0) # Clock for controlling frame rate clock = pygame.time.Clock() FPS = 60 # Box properties box_size = 300 box_center = (WIDTH // 2, HEIGHT // 2) angle = 0 # Initial rotation angle rotation_speed = 1 # Degrees per frame # Ball properties ball_radius = 10 ball_pos = [box_center[0], box_center[1] - box_size // 4] # Start near the top center of the box ball_velocity = [4, 0] # Initial velocity (x, y) gravity = 0.2 # Gravity effect # Function to rotate a point around another point def rotate_point(point, angle, origin): ox, oy = origin px, py = point qx = ox + math.cos(math.radians(angle)) * (px - ox) - math.sin(math.radians(angle)) * (py - oy) qy = oy + math.sin(math.radians(angle)) * (px - ox) + math.cos(math.radians(angle)) * (py - oy) return qx, qy # Main game loop running = True while running: screen.fill(BLACK) # Handle events for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # Update ball physics ball_velocity[1] += gravity # Apply gravity ball_pos[0] += ball_velocity[0] ball_pos[1] += ball_velocity[1] # Rotate the box angle += rotation_speed if angle >= 360: angle -= 360 # Define the four corners of the square corners = [ (-box_size / 2, -box_size / 2), (box_size / 2, -box_size / 2), (box_size / 2, box_size / 2), (-box_size / 2, box_size / 2) ] # Rotate the corners around the center rotated_corners = [rotate_point(corner, angle, box_center) for corner in corners] # Check collision with the edges of the box collided = False for i in range(4): p1 = rotated_corners[i] p2 = rotated_corners[(i + 1) % 4] # Line segment between p1 and p2 x1, y1 = p1 x2, y2 = p2 # Closest point on the line to the ball dx = x2 - x1 dy = y2 - y1 t = max(0, min(1, ((ball_pos[0] - x1) * dx + (ball_pos[1] - y1) * dy) / (dx * dx + dy * dy))) closest_x = x1 + t * dx closest_y = y1 + t * dy # Distance between ball and closest point distance_sq = (closest_x - ball_pos[0]) ** 2 + (closest_y - ball_pos[1]) ** 2 if distance_sq <= ball_radius ** 2: # Collision detected collided = True # Normal vector of the edge edge_length = math.hypot(dx, dy) nx = -dy / edge_length ny = dx / edge_length # Reflect the velocity vector dot_product = ball_velocity[0] * nx + ball_velocity[1] * ny ball_velocity[0] -= 2 * dot_product * nx ball_velocity[1] -= 2 * dot_product * ny # Ensure the ball stays inside the box if not collided: # Clamp the ball position within the box ball_pos[0] = max(box_center[0] - box_size / 2 + ball_radius, min(ball_pos[0], box_center[0] + box_size / 2 - ball_radius)) ball_pos[1] = max(box_center[1] - box_size / 2 + ball_radius, min(ball_pos[1], box_center[1] + box_size / 2 - ball_radius)) # Draw the rotating square pygame.draw.polygon(screen, WHITE, rotated_corners, 2) # Draw the ball pygame.draw.circle(screen, YELLOW, (int(ball_pos[0]), int(ball_pos[1])), ball_radius) # Update the display pygame.display.flip() # Cap the frame rate clock.tick(FPS) # Quit Pygame pygame.quit()

2. ChatGPT:n, Qwenin ja DeepSeekin vastausten vertailu klassiseen takaa-ajoon

Mitä tulee todellisten ongelmien ratkaisemiseen, kaikkia tekoälymalleja ei luoda samanarvoisiksi. Testatakseni heidän kykyjään esitin klassisen harjoitusongelman:

– Arvokas esine varastettiin. Omistaja aloitti takaa-ajon, kun varas oli paennut jo 45 km. Ajettuaan 160 km, omistaja huomasi, että varas oli 18 km edellä. Kuinka monta kilometriä omistajan pitää vielä matkustaa saadakseen varkaan kiinni?"

1. ChatGPT:n vastaus

ChatGPT:llä kesti 3 yritystä löytää oikea vastaus. Aluksi se tulkitsi ongelman väärin, mutta lopulta korjasi itsensä ja osoitti sinnikkyyttä, vaikka sillä ei ollut tehoa ensimmäisillä yrityksillä

2. DeepSeekin vastaus

DeepSeek vastasi myös oikein ensimmäisellä yrityksellä , mutta kesti hieman kauemmin kuin Qwen. Se toimitti yksityiskohtaisen, vaiheittaisen ratkaisun selkeällä perustelulla, mikä osoitti vahvuutensa syvällisessä ajattelussa ja tarkkuudessa

2. Qwenin vastaus

Qwen vastasi oikein ensimmäisellä yrittämällä ja teki sen nopeammin kuin DeepSeek. Se tarjosi tiiviin ja tarkan ratkaisun ilman tarpeettomia vaiheita ja esitteli vahvaa ongelmanratkaisun nopeutta ja tarkkuutta.

Johtopäätös

Vaikka kaikki kolme tekoälyä vastasivat lopulta oikein, Qwen erottui nopeudestaan ja tehokkuudestaan, kun taas DeepSeek esitteli menetelmällistä lähestymistapaansa. ChatGPT vaati useita yrityksiä

Tekoälyn humanisoiva sisältö: Tekoälyn inhimillinen puoli

Vaikka nopeutta ja tehokkuutta juhlitaan usein tekoälyssä, todellinen pelin muuttaja on tunneäly – kyky ymmärtää, tulkita ja reagoida ihmisten tunteisiin. Tekoälymallit, kuten DeepSeek, loistavat tarkkuudessa ja logiikassa, ja ChatGPT loistaa luovuudessa. Testataanpa sitä

— — — — — — — —

Kehotus: Write a messy emotional love letter

— — — — — — — —

Chatgpt:

Deepseek:

Qwen:

Mielenkiintoista on, että kun kaikki kolme mallia – ChatGPT, DeepSeek ja Qwen – testattiin ihmisen kaltaisen omaperäisyyden suhteen, he yrittivät päästä irti tekoälyn luomista malleista. HUOMAA: kaikki kolme aloittivat vastauksensa samalla robottilinjalla: "En edes tiedä mistä aloittaa" . Oli miten oli, minulla oli korkeat odotukset Chatgpt:n kanssa, mutta Qwen voitti!

Tärkeimmät takeawayt:

DeepSeek *: Tutkimuksen ja kriittisen ajattelun lähde, joka ylittää muut tarkkuudessa ja syvyydessä.*

Qwen *: Ratkaisi klassisen arvoituksen ensimmäisellä kerralla DeepSeekin kanssa ja voitti humanisoidussa sisällössä , mikä teki siitä vahvan monitoimilaitteen.*

ChatGPT *: Kesti useita yrityksiä ratkaista arvoitus, mutta se on edelleen paras valinta luoviin tehtäviin ja ihmisen kaltaiseen vuorovaikutukseen .*

Lopullinen tuomio: kenen pitäisi käyttää mitä tekoälyä?

• Tutkijat : DeepSeek
• Insinöörit : DeepSeek
• Kirjoittajat : ChatGPT tai Qwen
• Asianajajat : Qwen withchatgpt
• Kouluttajat : ChatGPT
• Sisällöntuottajat : Qwen ja syvällinen ajattelu Deepseekistä

Johtopäätös:

Haluaisin kuulla mielipiteesi kommenteissa ja korjata minua, jos olet väärässä. Jos pidit tästä artikkelista hyödyllisenä, taputa, jaa ja jaa näkemyksesi. Voit vapaasti tukea minua *** tässä ***tai UPI: jainhvj@fam

Olen innoissani voidessani jatkaa oppimista ja tutkia tätä laajaa alaa. Arvostan palautettasi ja odotan oivaltavia keskusteluja

Kiitos!