ຕົວແບບ AI ໃດທີ່ປະຕິບັດໄດ້ດີກວ່າໃນ ການຂຽນລະຫັດ , ກົນຈັກ, ແລະຄວາມແມ່ນຍໍາຂອງສູດການຄິດໄລ່ —ຕົວແບບໃດທີ່ໃຫ້ຄວາມຊັດເຈນໃນໂລກແທ້?

ຍັກໃຫຍ່ດ້ານເທກໂນໂລຍີທີ່ຮັ່ງມີໃນສະຫະລັດຄັ້ງຫນຶ່ງໄດ້ຄອບງໍາຕະຫຼາດ AI ແຕ່ການປ່ອຍ DeepSeek ເຮັດໃຫ້ເກີດຄື້ນຟອງໃນອຸດສາຫະກໍາ, ເຮັດໃຫ້ເກີດການ hype ຢ່າງຫຼວງຫຼາຍ. ຢ່າງໃດກໍຕາມ, ຄືກັບວ່າບໍ່ພຽງພໍ, Qwen 2.5 ອອກມາ - ລື່ນກາຍ DeepSeek ໃນຫຼາຍຂົງເຂດ. ເຊັ່ນດຽວກັນກັບແບບຈໍາລອງເຫດຜົນອື່ນໆເຊັ່ນ DeepSeek-R1 ແລະ OpenAI's O1, Qwen 2.5-Max ດໍາເນີນການໃນລັກສະນະທີ່ປິດບັງຂະບວນການຄິດຂອງມັນ, ເຮັດໃຫ້ມັນຍາກທີ່ຈະຕິດຕາມເຫດຜົນການຕັດສິນໃຈຂອງຕົນ.

ບົດຂຽນນີ້ເຮັດໃຫ້ ChatGPT, Qwen, ແລະ DeepSeek ກ້າວໄປສູ່ຄວາມທ້າທາຍອັນສຳຄັນຕ່າງໆຕັ້ງແຕ່ ການແກ້ໄຂບັນຫາການຄິດໄລ່ ເຖິງ ການແກ້ບັນຫາລະຫັດ . ບໍ່ວ່າທ່ານຈະເປັນ ຜູ້ພັດທະນາການລ່າສັດສໍາລັບຜູ້ຊ່ວຍການເຂົ້າລະຫັດ AI ທີ່ສົມບູນແບບ , ນັກຄົ້ນຄວ້າແກ້ໄຂບັນຫາກົນຈັກ quantum , ຫຼື ຜູ້ຊ່ຽວຊານດ້ານທຸລະກິດ , ມື້ນີ້ຂ້ອຍຈະພະຍາຍາມເປີດເຜີຍວ່າຕົວແບບໃດເປັນທາງເລືອກທີ່ສະຫລາດທີ່ສຸດສໍາລັບຄວາມຕ້ອງການຂອງເຈົ້າ (ແລະງົບປະມານ)

ການວິເຄາະປຽບທຽບຄວາມສາມາດຂອງຕົວແບບ AI:-

1. Chatgpt

ChatGPT, ພັດທະນາໂດຍ OpenAI ຍັງຄົງເປັນກໍາລັງທີ່ເດັ່ນຊັດໃນພື້ນທີ່ AI, ສ້າງຂຶ້ນໃນ ສະຖາປັດຕະຍະກໍາ GPT-5 ທີ່ມີປະສິດທິພາບ ແລະຖືກປັບລະອຽດໂດຍໃຊ້ Reinforcement Learning from Human Feedback (RLHF) . ມັນເປັນການໄປທີ່ຫນ້າເຊື່ອຖືສໍາລັບວຽກງານຕ່າງໆ, ຈາກການຂຽນທີ່ສ້າງສັນໄປຫາເອກະສານດ້ານວິຊາການ, ເຮັດໃຫ້ມັນເປັນທາງເລືອກອັນດັບຫນຶ່ງສໍາລັບຜູ້ສ້າງເນື້ອຫາ, ການສຶກສາແລະຜູ້ເລີ່ມຕົ້ນ, ຢ່າງໃດກໍຕາມ, ມັນບໍ່ສົມບູນແບບ. ເມື່ອເວົ້າເຖິງສາຂາວິຊາສະເພາະ, ເຊັ່ນ: ຄະນິດສາດຂັ້ນສູງ ຫຼື ໂດເມນທາງດ້ານກົດໝາຍ, ມັນສາມາດຕໍ່ສູ້ໄດ້. ນອກຈາກນັ້ນ, ຄ່າໃຊ້ຈ່າຍໃນພື້ນຖານໂຄງລ່າງທີ່ສູງຂອງມັນເຮັດໃຫ້ມັນຍາກສໍາລັບທຸລະກິດຂະຫນາດນ້ອຍຫຼືຜູ້ພັດທະນາສ່ວນບຸກຄົນທີ່ຈະເຂົ້າເຖິງໄດ້ງ່າຍ

ChatGPT, ສ້າງຂຶ້ນດ້ວຍການລົງທຶນຫຼາຍ $3B+, ເປັນຕົວແບບພື້ນຖານໂຄງລ່າງອັນໃຫຍ່ຫຼວງ, ໃນຂະນະທີ່ DeepSeek ໄດ້ບັນລຸປະສິດທິພາບທີ່ຄ້າຍຄືກັນກັບພຽງແຕ່ $5.6 ລ້ານ — ຊ່ວງເວລາຂອງຈີນຄລາສສິກ huh?

2. ເຈາະເລິກ

ບໍ່ມີບ່ອນໃດ, DeepSeek ກາຍເປັນມ້າມືດໃນການແຂ່ງຂັນ AI ທີ່ທ້າທາຍຍັກໃຫຍ່ທີ່ສ້າງຕັ້ງຂຶ້ນໂດຍສຸມໃສ່ ຄວາມແມ່ນຍໍາຂອງຄອມພິວເຕີ້ແລະປະສິດທິພາບ.

ບໍ່ເຫມືອນກັບຄູ່ແຂ່ງຂອງມັນ, ມັນຖືກປັບແຕ່ງສໍາລັບວຽກງານວິທະຍາສາດແລະຄະນິດສາດແລະໄດ້ຮັບການຝຶກອົບຮົມໃນຊຸດຂໍ້ມູນຊັ້ນນໍາເຊັ່ນ arXiv ແລະ Wolfram Alph a, ເຊິ່ງຊ່ວຍໃຫ້ມັນປະຕິບັດໄດ້ດີໃນດ້ານຕ່າງໆເຊັ່ນ: ການເພີ່ມປະສິດທິພາບ, ການຈໍາລອງຟີຊິກ , ແລະ ບັນຫາຄະນິດສາດ ທີ່ສັບສົນ . ຄວາມເຂັ້ມແຂງທີ່ແທ້ຈິງຂອງ DeepSeek ແມ່ນລາຄາຖືກເທົ່າໃດ (ບໍ່ມີຈຸດມຸ່ງຫມາຍຂອງຈີນ 😤). ໃນຂະນະທີ່ຕົວແບບເຊັ່ນ ChatGPT ແລະ Qwen ຕ້ອງການຊັບພະຍາກອນອັນໃຫຍ່ຫຼວງ, Deepseek ເຮັດວຽກດ້ວຍຄ່າໃຊ້ຈ່າຍຫນ້ອຍລົງ. ດັ່ງນັ້ນແມ່ນແລ້ວ, ທ່ານບໍ່ຈໍາເປັນຕ້ອງໄດ້ຮັບ $1000 ສໍາລັບການສະຫມັກ ChatGPT

ວິທີການຕອບສະຫນອງຂອງ DeepSeek ມີຄວາມຮູ້ສຶກເປັນຫຸ່ນຍົນເລັກນ້ອຍ, ແລະມັນປັບຕົວເຂົ້າກັບວຽກງານທີ່ບໍ່ມີເຕັກນິກເກີນໄປ. ມັນດີຫຼາຍສຳລັບສາຂາວິຊາສະເພາະເຊັ່ນ: ຄະນິດສາດ ແລະການຄົ້ນຄວ້າ ແຕ່ບໍ່ແມ່ນສຳລັບການສົນທະນາແບບທຳມະດາ ຫຼືສ້າງສັນ

3. ຄິວເວິນ

ຫຼັງຈາກ Deepseek ໃຜຈະຄິດວ່າ AI ຂອງຈີນອື່ນຈະປາກົດຂຶ້ນແລະເລີ່ມຕົ້ນການຄອບຄອງ? ການເຄື່ອນໄຫວແບບຄລາສສິກຂອງຈີນ - ເຜີຍແຜ່ບາງສິ່ງບາງຢ່າງແລະເວລານີ້ແມ່ນ AI lol

Qwen ກໍາລັງຄອບງໍາເກມທຸລະກິດດ້ວຍການຕັ້ງຄ່າຫຼາຍພາສາ, ທີ່ດີເລີດໃນສະຖານທີ່ຕ່າງໆເຊັ່ນອາຊີ, ໂດຍສະເພາະກັບພາສາຈີນກາງແລະພາສາອາຫລັບ. ມັນເປັນການປະຕິບັດທາງດ້ານກົດຫມາຍແລະທາງດ້ານການເງິນ, ແລະມັນບໍ່ແມ່ນຮູບແບບທີ່ສົມເຫດສົມຜົນເຊັ່ນ DeepSeek R1, ຊຶ່ງຫມາຍຄວາມວ່າທ່ານບໍ່ສາມາດເຫັນຂະບວນການຄິດຂອງມັນ. ແຕ່ຄືກັນກັບ DeepSeek, ມັນມີອາລົມຫຸ່ນຍົນ, ເຮັດໃຫ້ມັນມ່ວນໜ້ອຍລົງສຳລັບການເຮັດວຽກແບບສະບາຍໆ ຫຼືສ້າງສັນ. ຖ້າທ່ານຕ້ອງການບາງສິ່ງບາງຢ່າງທີ່ມີຄວາມຍືດຫຍຸ່ນຫຼາຍ, Qwen ອາດຈະບໍ່ເປັນ hang ທີ່ດີທີ່ສຸດ

ທ່ານສາມາດຄິດມັນຄືກັບທີມງານຜູ້ຊ່ຽວຊານ: ຖ້າທ່ານຖາມຄໍາຖາມທີ່ສັບສົນກ່ຽວກັບຟີຊິກ, ພຽງແຕ່ຜູ້ຊ່ຽວຊານດ້ານຟີຊິກຕອບ, ໃນຂະນະທີ່ທີມງານສ່ວນທີ່ເຫຼືອບໍ່ເຄື່ອນໄຫວ.

ເວລາທົດສອບ: ປຽບທຽບ AI 3 ອັນກັບບັນຫາໂລກທີ່ແທ້ຈິງ

ເພື່ອຮັບປະກັນຄວາມຍຸຕິທຳ ແລະ ຜ່ານການປະເມີນ, ໃຫ້ພວກເຮົາຖິ້ມສິ່ງທ້າທາຍທີ່ໜ້າລັງກຽດທີ່ສຸດ ເຊັ່ນ: ບັນຫາທາງຄະນິດສາດທີ່ຍາກລຳບາກ, ຟີຊິກສາດ, ວຽກງານການຂຽນລະຫັດ, ແລະ ຄຳຖາມໃນຄວາມເປັນຈິງທີ່ຍາກລຳບາກ.

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

1. ຟີຊິກ: ບັນຫາບານຫມຸນ

ເພື່ອເລີ່ມຕົ້ນ, ໃຫ້ພວກເຮົາເຂົ້າໄປໃນບັນຫາຄລາສສິກ "ບານຫມຸນຢູ່ໃນກ່ອງ", ເຊິ່ງໄດ້ກາຍເປັນມາດຕະຖານທີ່ນິຍົມໃນການທົດສອບວ່າຕົວແບບ AI ທີ່ແຕກຕ່າງກັນຈັດການກັບວຽກທີ່ສັບສົນໄດ້ດີປານໃດ.

ສິ່ງທ້າທາຍ : ຈຳລອງບານທີ່ຕີຢູ່ໃນກ່ອງຫມຸນໃນຂະນະທີ່ປະຕິບັດຕາມກົດ ໝາຍ ຂອງຟີຊິກ

ຮູບພາບ 2 ມິຕິທີ່ຫມຸນຢູ່ໃນອາວະກາດ. ພາຍໃນ, ບານກະໂດດອອກຈາກຝາ, ຢູ່ໃນຂອບເຂດແລະບໍ່ມີຜົນບັງຄັບໃຊ້ພາຍນອກ. ຢູ່ glance ທໍາອິດ, ມັນອາດຈະເບິ່ງຄືວ່າງ່າຍດາຍ , ແຕ່ການບັນຊີສໍາລັບແຮງໂນ້ມຖ່ວງ, ພືດຫມູນວຽນຄົງທີ່, ແລະນະໂຍບາຍດ້ານ collision ທີ່ຊັດເຈນເຮັດໃຫ້ມັນເປັນການຈໍາລອງທີ່ທ້າທາຍ. ເຈົ້າຈະປະຫລາດໃຈທີ່ແບບຈໍາລອງ AI ຈັດການກັບມັນແຕກຕ່າງກັນ

ເຕືອນ:-

 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

ຜົນໄດ້ຮັບ:

1. ຜົນຜະລິດຂອງ ChatGPT: ໄວແຕ່ມີຂໍ້ບົກພ່ອງ

ດ້ວຍ Chatgpt ຂ້ອຍມີຄວາມຄາດຫວັງສູງ. ແຕ່ຜົນໄດ້ຮັບ? ໃຫ້ຂອງພຽງແຕ່ເວົ້າວ່າພວກເຂົາເຈົ້າໄດ້… underwhelming. ໃນຂະນະທີ່ DeepSeek ໃຊ້ເວລາຂອງຕົນສໍາລັບຄວາມຖືກຕ້ອງ, ChatGPT ທັນທີທັນໃດ spat ອອກ script ທີ່ສະອາດ. ບານບໍ່ໄດ້ຕີຕາມຄວາມເປັນຈິງ. ແທນທີ່ຈະ, ມັນ ຂັດຢູ່ແຄມຂອງກ່ອງ , ບາງຄັ້ງກໍ່ຕິດຢູ່ໃນມຸມຫຼືຕັດຜ່ານຝາ. ມັນເປັນທີ່ຊັດເຈນວ່າ ChatGPT ມັກຄວາມໄວເກີນຄວາມເລິກ, ສະຫນອງການແກ້ໄຂທີ່ເຮັດວຽກ - ແຕ່ໃນຄວາມຫມາຍພື້ນຖານທີ່ສຸດເທົ່ານັ້ນ

ລະຫັດ Chatgpt:

 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()

ຜົນຜະລິດ:

2. Deepseek

ຜົນຜະລິດຂອງ DeepSeek ເຮັດໃຫ້ຂ້ອຍປະຫລາດໃຈແທ້ໆ. ໃນຂະນະທີ່ ChatGPT ແມ່ນໄວໃນການສ້າງລະຫັດ, DeepSeek ໃຊ້ເວລາ 200 ວິນາທີເພື່ອຄິດກ່ຽວກັບບັນຫາ. DeepSeek ບໍ່ພຽງແຕ່ຂຽນ script ທີ່ເປັນປະໂຫຍດ ; ມັນສ້າງ ການຈຳລອງທາງຟີຊິກທີ່ເໝາະສົມທີ່ສຸດ ແລະ ຖືກຕ້ອງທີ່ສຸດ ທີ່ຈັດການທຸກຂອບໄດ້ຢ່າງບໍ່ມີຂໍ້ບົກພ່ອງ.

ລະຫັດ DeepSeek:

 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()

ຜົນຜະລິດ:

3. ຜົນໄດ້ຮັບຂອງ Qwen: ຄວາມພະຍາຍາມທີ່ຫນ້າຜິດຫວັງ

ຖ້າຜົນຜະລິດຂອງ ChatGPT ແມ່ນ underwhelming, Qwen's ມີຄວາມຜິດຫວັງຢ່າງແທ້ຈິງ . ເນື່ອງຈາກຊື່ສຽງທີ່ເຂັ້ມແຂງຂອງ Qwen ສໍາລັບການຈັດການວຽກງານທີ່ສັບສົນ, ຂ້າພະເຈົ້າກໍ່ມີຄວາມຄາດຫວັງສູງສໍາລັບການປະຕິບັດງານຂອງມັນ. ແຕ່ເມື່ອຂ້ອຍແລ່ນລະຫັດຂອງມັນສໍາລັບການຈໍາລອງບານຫມຸນ, ຜົນໄດ້ຮັບແມ່ນ ຢູ່ໄກຈາກສິ່ງທີ່ຂ້ອຍຄາດຫວັງ . ເຊັ່ນດຽວກັນກັບ ChatGPT, Qwen ສ້າງລະຫັດເກືອບທັນທີ - ບໍ່ມີຄວາມຄິດເລິກເຊິ່ງ.

ບານແມ່ນຢູ່ນອກກ່ອງ ສໍາ ລັບການຈໍາລອງສ່ວນໃຫຍ່, ຂັດຂວາງກົດຫມາຍຂອງຟີຊິກຢ່າງສົມບູນ.

ລະຫັດຂອງ Qwen

 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, Qwen ແລະ DeepSeek ກັບເກມແຂ່ງລົດແບບຄລາສສິກ.

ໃນເວລາທີ່ມັນມາກັບການແກ້ໄຂບັນຫາທີ່ແທ້ຈິງ, ບໍ່ແມ່ນທຸກແບບ AI ໄດ້ຖືກສ້າງຂື້ນເທົ່າທຽມກັນ. ເພື່ອທົດສອບຄວາມສາມາດຂອງພວກເຂົາ, ຂ້າພະເຈົ້າໄດ້ນໍາສະເຫນີບັນຫາການສະແຫວງຫາແບບຄລາສສິກ:

“ວັດຖຸບູຮານອັນລ້ຳຄ່າຖືກລັກ. ເຈົ້າ​ຂອງ​ໄດ້​ເລີ່ມ​ຕົ້ນ​ການ​ໄລ່​ຕາມ​ຫຼັງ​ຈາກ​ທີ່​ໂຈນ​ໄດ້​ຫນີ​ໄປ​ແລ້ວ 45 ກິ​ໂລ​ແມັດ​. ຫຼັງ​ຈາກ​ເດີນ​ທາງ 160 ກິ​ໂລ​ແມັດ, ເຈົ້າ​ຂອງ​ໄດ້​ຄົ້ນ​ພົບ​ໂຈນ​ຍັງ 18 ກິ​ໂລ​ແມັດ​ຂ້າງ​ຫນ້າ. ເຈົ້າຂອງຕ້ອງເດີນທາງອີກຈັກກິໂລແມັດເພື່ອຈັບໂຈນ?”

1. ຄໍາຕອບຂອງ ChatGPT

ChatGPT ໄດ້ ພະຍາຍາມ 3 ເທື່ອ ເພື່ອມາຮອດຄຳຕອບທີ່ຖືກຕ້ອງ. ໃນເບື້ອງຕົ້ນ, ມັນໄດ້ຕີຄວາມຜິດບັນຫາແຕ່ໃນທີ່ສຸດກໍແກ້ໄຂຕົວມັນເອງ, ສະແດງໃຫ້ເຫັນຄວາມອົດທົນເຖິງແມ່ນວ່າຂາດປະສິດທິພາບໃນຄວາມພະຍາຍາມທໍາອິດຂອງຕົນ.

2. ຄໍາຕອບຂອງ DeepSeek

DeepSeek ຍັງຕອບຢ່າງຖືກຕ້ອງໃນ ການທົດລອງຄັ້ງທໍາອິດ ແຕ່ໃຊ້ເວລາດົນກວ່າ Qwen ເລັກນ້ອຍ. ມັນສະຫນອງການແກ້ໄຂຢ່າງລະອຽດ, ຂັ້ນຕອນໂດຍຂັ້ນຕອນດ້ວຍເຫດຜົນທີ່ຊັດເຈນ, ພິສູດຄວາມເຂັ້ມແຂງຂອງມັນໃນ ຄວາມຄິດທີ່ເລິກເຊິ່ງ ແລະຄວາມຖືກຕ້ອງ.

2. ຄໍາຕອບຂອງ Qwen

Qwen ຕອບຢ່າງຖືກຕ້ອງໃນ ການທົດລອງຄັ້ງທໍາອິດ ແລະເຮັດ ໄວກວ່າ DeepSeek. ມັນສະຫນອງການແກ້ໄຂທີ່ຊັດເຈນແລະຖືກຕ້ອງໂດຍບໍ່ມີຂັ້ນຕອນທີ່ບໍ່ຈໍາເປັນ, ສະແດງໃຫ້ເຫັນຄວາມໄວໃນການແກ້ໄຂບັນຫາທີ່ເຂັ້ມແຂງແລະຄວາມແມ່ນຍໍາ.

ສະຫຼຸບ

ໃນຂະນະທີ່ທັງສາມ AI ໃນທີ່ສຸດກໍ່ຕອບຢ່າງຖືກຕ້ອງ, Qwen ຢືນອອກສໍາລັບຄວາມໄວແລະປະສິດທິພາບຂອງມັນ, ໃນຂະນະທີ່ DeepSeek ສະແດງໃຫ້ເຫັນວິທີການວິທີການຂອງຕົນ. ChatGPT ຕ້ອງການຄວາມພະຍາຍາມຫຼາຍຄັ້ງ

Humanizing AI Content: ດ້ານມະນຸດຂອງ AI

ໃນຂະນະທີ່ຄວາມໄວ ແລະປະສິດທິພາບມັກຈະຖືກສະຫຼອງໃນ AI, ຕົວປ່ຽນແປງເກມທີ່ແທ້ຈິງແມ່ນ ຄວາມສະຫຼາດທາງດ້ານອາລົມ — ຄວາມສາມາດໃນການເຂົ້າໃຈ, ຕີຄວາມໝາຍ ແລະຕອບສະໜອງຕໍ່ອາລົມຂອງມະນຸດ. ໃນຂະນະທີ່ຕົວແບບ AI ເຊັ່ນ DeepSeek ດີເລີດໃນຄວາມແມ່ນຍໍາແລະເຫດຜົນ, ແລະ ChatGPT ສ່ອງແສງໃນຄວາມຄິດສ້າງສັນ. ໃຫ້ທົດສອບມັນອອກ

——————————

ການເຕືອນ: Write a messy emotional love letter

——————————

Chatgpt:

Deepseek:

Qwen:

ຫນ້າສົນໃຈ, ໃນເວລາທີ່ການທົດສອບສໍາລັບ ຕົ້ນສະບັບຄ້າຍຄືມະນຸດ , ທັງສາມແບບ - ChatGPT, DeepSeek, ແລະ Qwen - ໄດ້ຕໍ່ສູ້ເພື່ອປົດປ່ອຍຈາກຮູບແບບທີ່ສ້າງຂຶ້ນ AI ຂອງເຂົາເຈົ້າ. ຫມາຍເຫດ: ທັງສາມຄົນໄດ້ເລີ່ມຕົ້ນການຕອບໂຕ້ຂອງພວກເຂົາດ້ວຍຫຸ່ນຍົນດຽວກັນ: "ຂ້ອຍບໍ່ຮູ້ວ່າຈະເລີ່ມຕົ້ນຢູ່ໃສ" . ແນວໃດຂ້າພະເຈົ້າມີຄວາມຄາດຫວັງສູງກັບ Chatgpt ແຕ່ Qwen ຊະນະ!

ການຮັບເອົາຫຼັກ:

DeepSeek *: ການໄປເພື່ອ ການຄົ້ນຄວ້າ ແລະ ຄິດວິຈານ , ປະສິດທິພາບຫຼາຍກວ່າຄົນອື່ນໃນຄວາມແມ່ນຍໍາແລະຄວາມເລິກ.*

Qwen *: ຈັບຄູ່ກັບ DeepSeek ໃນການແກ້ບັນຫາແບບເກົ່າໆໃນການທົດລອງຄັ້ງທຳອິດ ແລະໄດ້ຮັບໄຊຊະນະໃນ ເນື້ອຫາມະນຸດ , ເຮັດໃຫ້ມັນເປັນທຸກຮອບທີ່ເຂັ້ມແຂງ.*

ChatGPT *: ໄດ້ພະຍາຍາມຫຼາຍຄັ້ງເພື່ອແກ້ໄຂຂໍ້ຫຍຸ້ງຍາກ ແຕ່ຍັງຄົງເປັນທາງເລືອກອັນດັບຕົ້ນໆສໍາລັບ ວຽກທີ່ສ້າງສັນ ແລະ ການໂຕ້ຕອບທີ່ຄ້າຍຄືກັບມະນຸດ .*

ຄໍາຕັດສິນສຸດທ້າຍ: ໃຜຄວນໃຊ້ AI ໃດ?

• ນັກຄົ້ນຄວ້າ : DeepSeek
• ວິສະວະກອນ : DeepSeek
• ນັກຂຽນ : ChatGPT ຫຼື Qwen
• ທະນາຍຄວາມ : Qwen withchatgpt
• ການສຶກສາ : ChatGPT
• ຜູ້ສ້າງເນື້ອຫາ : Qwen ແລະການຄິດເລິກຈາກ Deepseek

ສະຫຼຸບ:

ຂ້ອຍຢາກໄດ້ຍິນ ຄຳ ເຫັນຂອງເຈົ້າໃນ ຄຳ ເຫັນແລະແກ້ໄຂຂ້ອຍຖ້າຜິດ. ຖ້າ​ຫາກ​ທ່ານ​ພົບ​ເຫັນ​ບົດ​ຄວາມ​ນີ້​ເປັນ​ປະ​ໂຫຍດ​, clap​, ແບ່ງ​ປັນ​, ແລະ​ແບ່ງ​ປັນ​ທັດ​ສະ​ນະ​ຂອງ​ທ່ານ​. ຮູ້ສຶກວ່າບໍ່ເສຍຄ່າເພື່ອສະຫນັບສະຫນູນຂ້ອຍ *** ທີ່ນີ້ *** ຫຼື UPI: jainhvj@fam

ຂ້ອຍຕື່ນເຕັ້ນທີ່ຈະສືບຕໍ່ຮຽນຮູ້ ແລະສຳຫຼວດພື້ນທີ່ກວ້າງໃຫຍ່ນີ້. ຂ້ອຍຂອບໃຈຄໍາຄິດເຫັນຂອງເຈົ້າແລະຫວັງວ່າຈະມີການສົນທະນາທີ່ເລິກເຊິ່ງ

ຂອບໃຈ!