שיתוף | ChatGPT - הצ'אטבוט החדש של OpenAI ; לכתיבת תסריטים

[GIGA]

@NH-LOCAL זה דוגמה יפה כדי להבין איך הוא מחליט לשלוח לך את התשובה הספציפית הזו, מתוך כמה תשובות שהוא הפיק. נראה שהוא מספק לעצמו ציונים על סמך השיחה הספציפית הזו כדי לדעת אם הפלט שהוא יפיק יהיה קשור.

Spoiler

ולמי שמבין קצת ברשתות נוירונים: המודל של ChatGPT הוא מבוסס GAN, והוא משתמש ברשת אחת שמפיקה נתונים ואחת שבודקת אותם אם הם מתאימים לטווח התפלגות מסויים (נניח הרשת הגנרטיבית ממציאה מכתב קבלה לאגודה לשחמט, אז הרשת הדיסקרימינטיבית (שזה שם קצת מפוצץ לכך שהרשת לא מנסה לסווג תכונות אלא רק לקטלג אובייקטים מתוך מאגר) מחליטה אם זה עומד במקום סביר בהתפלגות של מכתבים, מכתבי קבלה, אגודות שחמט, וכו', ונותנת ציון בינארי).
ככל שיש יש יותר הלוך חזור בין שתי המערכות, אז הפלט מדויק יותר (ושוב, מדוייק יותר אין משמעו נכון יותר אלא קשור יותר, במובן של קשר בין קבוצות (אשכולות) של הנושאים המדוברים).
העניין הוא, כמו כל רשתות נוירונים, זה שאין תשובה אחת לכל שאלה אלא סך של תשובות שנענות במקביל, והמערכת משקללת את כולם לכדי ציון (המבינים יסלחו לי על חוסר הדיוק הגס). וככל שכמות התשובות גדולה יותר, כך המערכת יודעת יותר להתאים לקבוצות שונות.
הבעיה היא שככל שכמות התשובות גדולה יותר, התשובה נהית ממש לא ממוקדת (אפשר לבקש מכתב קבלה, והמערכת תפיק קבלת מס בכתב יד לדוג') לבעיה הזו קוראים overfitting, ומצמצמים אותה ע"י שמאמנים כל הזמן את המערכת (ז"א, באופן ידני) מה נקרא פלט ראוי ומה לא.
לענייננו, יש עוד 2 טכניקות למנוע overfitting, והיא ע"י הזנה למערכת הגנרטיבית את הכלל (1) לעולם תעדיף תגובה פשוטה על פני מורכבת. ולמערכת הדיסקרימינטיבית: (2) קשר ישיר בין הנושאים שמצאת אצל המשתמש לבין תשובות המערכת יזכו בדירוג גבוה.
זו הסיבה לכך שאם תחפור לו כל הזמן על תכנות, גם אם תשאל שאלה לא קשורה, הוא יעדיף לקשר (כמה שהוא יכול, הוא לא תמיד מצליח) לתכנות.
הערה- כתבתי את האמור בלי מידע לגבי הקהל יעד, אם יש רצון להרחבה או להסבר אשמח, אולי אפ' לפתוח נושא חדש על בינה מלאכותית ולמידת מכונה. אם זה TooMuch, תתעלמו...

[חייםבמים12]

פוסט זה נמחק!

[מויטיו]

פוסט זה נמחק!

[צור]

לא מבין מי תכנת אותו (אפילו ויקיפדיה פשוטה)

[מישהו12]

@צור תנסה באנגלית

[צדיק וטוב לו 0]

@צור כתב בשיתוף | ChatGPT - הצ'אטבוט החדש של OpenAI ; לכתיבת תסריטים:

לא מבין מי תכנת אותו (אפילו ויקיפדיה פשוטה)

מה, אצלכם לא נוהגים לאכול זכוכית שוקולד ופסטה?
חבל, ההפסד כולו שלכם.
אהה, כנראה זה בגלל שאתם חוגגים את חג החנוכה, ולא את 'חד חנוכה'.

[מוטי מן]

@GIGA כתב בשיתוף | ChatGPT - הצ'אטבוט החדש של OpenAI ; לכתיבת תסריטים:

יש אפשרות לבקש ממנו בעברית אבל אם אתה מבקש חיבור בעברית, הוא נותן לך משהו מאוד עילג... זה נראה כאילו הוא כתב באנגלית ותירגם לבד.

@NH-LOCAL אני שואל אותו ע"פ רוב באנגלית בגלל העילגות, ופעם אחת בתוך שיחה שלמה באנגלית כתבתי לו משפט אחד של 6-7 מילים בעברית, והוא ענה לי באנגלית שהוא ממש מצטער אבל מכיון שהתחלתי את השיחה באנגלית, הוא לא מצליח לתרגם בעזרת גוגל טרנסלייט את הבקשה שלי... לדעתי הוא לא באמת התכווין שהוא משתמש בגוגל טרנסלייט שהרי לאופן AI יש מודול תרגום מבוסס בינה יותר מוצלח מטרנסלייט, אבל הוא כנראה למד את הביטוי "גוגל טרנסלייט" כשהאכילו אותו בתוכן של כל המרשתת...

[מוטי מן]

@NH-LOCAL כתב בשיתוף | ChatGPT - הצ'אטבוט החדש של OpenAI ; לכתיבת תסריטים:

@צדיק-תמים לכל אחד הוא עונה תשובה אחרת כמובן. וזה בדיוק ההבדל בינו לבין גוגל. התשובה נוצרה בו ברגע ממש שקיבלת אותה...

זה מה שקיבלתי לאחר שהתכתבתי אתו בתכנות....:

הפדיחות העילגות האלה קורות בד"כ רק בעברית בגלל התרגום הוא קורא את המילה "תנא" כמשורש תנאי (if) ואיכשהו הנבואית הפכה לנבוכית...

[איש נחמד]

שימו לב לבדוק טוב כל שורה בקוד שהוא נותן לכם
קיבלתי ממנו בשבוע שעבר קוד שמכיל את הפונקציה ב-PHP

include( $file, $args );

הבעיה הקטנה היא שלפי התיעוד הרשמי הפונקציה הזו בנויה לקבל משתנה אחד בדיוק ולא יותר

[מתכנת חובב]

@איש-נחמד קורא לי כמעט בכל תוכנית פייתון שהוא מדפיס לי - הוא משלב בה פונקציות שלא קיימות

[מוטי מן]

@מתכנת-חובב אכן, אני גם ביקשתי ממנו לכתוב לי קוד js מסויים לארגון המיילים שלי בתוויות, והוא פוט המציא פונקציה שנקראת "צור תווית" שלא קיימת ומעולם לא הייתה קיימת!! וכשכתבתי לו שאין כזו פונקציה, הוא ברוב עזותו טען שאכן, הפונקציה כבר לא זמינה אבל המשיך להביא לי את המילים "צור תווית" באנגלית כמובן בכל מיני ויראציות שהוא המציא....

[בוגאטי]

היכולת שלו לכתוב קוד מבוססת על Open AI Codex.
בנוגע לשגיאות, ביקשתי ממנו ליצור קוד ב #C למטרה מסוימת ויצא קוד באורך 400 שורות עם שגיאה אחת בלבד (לפי Visual Studio), ניסיתי לתקן אותה, אבל הבעיה היא שזה משפיע על כל הקוד, ולא ממש היה לי כוח לנתח 400 שורות...
חוץ מזה ניסיתי קודים אחרים קצרים יותר (בעיקר #C) ויצא יותר טוב ממה שהייתי עושה בעצמי!

[מתכנת חובב]

@בוגאטי בדקת שגם אם תתקן הכל עובד כמו שצריך?
ובכלל, איך הוא הוציא לך 400 שורות?
הוא מוגבל במספר התווים ככה ש 400 שורות נשמע מוזר
בכל אופן, בכתיבה של פונקציות בודדות הוא וודאי אלוף אבל בתוכנית שלמה ומורכבת שתעבוד חלק בלי שום בעיה - קשה לראות אצלו

[elazar]

@מתכנת-חובב כתב בשיתוף | ChatGPT - הצ'אטבוט החדש של OpenAI ; לכתיבת תסריטים:

בכל אופן, בכתיבה של פונקציות בודדות הוא וודאי אלוף

ברקורסיה הוא גרוע לפחות ממה שאני ניסיתי.

[NH.LOCAL]

@elazar לאו דוקא. לי הוא הוציא כמה דברים יפים למדי שעוברים על עץ תיקיות - בפייתון

[elazar]

@NH-LOCAL האמת שניסיתי דברים שיש להם כמה מקרי קצה ולא ניסיתי רקורסיות ממש פשוטות. בJAVA .

[בוגאטי]

@מתכנת-חובב שכחתי לציין שעשיתי את זה ב Open AI Codex ולא בצ'אט ושם המגבלה היא 16000 תווים כמדומני.

@מתכנת-חובב כתב בשיתוף | ChatGPT - הצ'אטבוט החדש של OpenAI ; לכתיבת תסריטים:

בדקת שגם אם תתקן הכל עובד כמו שצריך?

יתכן שאתה צודק, אבל כפי שאמרתי לא היה לי כוח לעבור על הכל, זה גם ככה לא היה משהו חשוב כל כך אלא יותר לשם השעשוע.
אגב, יצרתי עם זה עכשיו קוד #C למשחק סנייק באורך 180 שורות ועבד מצויין, רק הבעיה שכיווני החיצים הפוכים וזה ממש מבלבל...
אם מעניין אותך, הנה הקוד, אני הפעלתי אותו ב Visual studio ע"י יצירת פרוייקט
Console App (.NET Framework) :

using System;

namespace SnakeGame
{
    class Program
    {
        static void Main(string[] args)
        {
            // Set up the game board
            int boardWidth = 20;
            int boardHeight = 20;
            char[,] board = new char[boardWidth, boardHeight];
            for (int i = 0; i < boardWidth; i++)
            {
                for (int j = 0; j < boardHeight; j++)
                {
                    board[i, j] = ' ';
                }
            }

            // Set up the snake
            int snakeLength = 5;
            int[] snakeX = new int[snakeLength];
            int[] snakeY = new int[snakeLength];
            for (int i = 0; i < snakeLength; i++)
            {
                snakeX[i] = boardWidth / 2;
                snakeY[i] = boardHeight / 2;
            }

            // Set up the food
            int foodX = 0;
            int foodY = 0;
            Random random = new Random();
            while (true)
            {
                foodX = random.Next(0, boardWidth);
                foodY = random.Next(0, boardHeight);
                if (board[foodX, foodY] == ' ')
                {
                    break;
                }
            }

            // Set up the game variables
            int score = 0;
            int direction = 0; // 0 = up, 1 = right, 2 = down, 3 = left
            bool gameOver = false;

            // Main game loop
            while (!gameOver)
            {
                // Draw the board
                Console.Clear();
                for (int i = 0; i < boardWidth; i++)
                {
                    for (int j = 0; j < boardHeight; j++)
                    {
                        if (i == 0 || i == boardWidth - 1 || j == 0 || j == boardHeight - 1)
                        {
                            Console.Write('#');
                        }
                        else
                        {
                            Console.Write(board[i, j]);
                        }
                    }
                    Console.WriteLine();
                }

                // Draw the score
                Console.WriteLine("Score: " + score);

                // Get the user input
                ConsoleKeyInfo keyInfo = Console.ReadKey();
                switch (keyInfo.Key)
                {
                    case ConsoleKey.UpArrow:
                        if (direction != 2)
                        {
                            direction = 0;
                        }
                        break;
                    case ConsoleKey.RightArrow:
                        if (direction != 3)
                        {
                            direction = 1;
                        }
                        break;
                    case ConsoleKey.DownArrow:
                        if (direction != 0)
                        {
                            direction = 2;
                        }
                        break;
                    case ConsoleKey.LeftArrow:
                        if (direction != 1)
                        {
                            direction = 3;
                        }
                        break;
                }

                // Move the snake
                for (int i = snakeLength - 1; i > 0; i--)
                {
                    snakeX[i] = snakeX[i - 1];
                    snakeY[i] = snakeY[i - 1];
                }
                switch (direction)
                {
                    case 0:
                        snakeY[0]--;
                        break;
                    case 1:
                        snakeX[0]++;
                        break;
                    case 2:
                        snakeY[0]++;
                        break;
                    case 3:
                        snakeX[0]--;
                        break;
                }

                // Check for game over
                if (snakeX[0] == 0 || snakeX[0] == boardWidth - 1 || snakeY[0] == 0 || snakeY[0] == boardHeight - 1)
                {
                    gameOver = true;
                }
                for (int i = 1; i < snakeLength; i++)
                {
                    if (snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i])
                    {
                        gameOver = true;
                    }
                }

                // Check for food
                if (snakeX[0] == foodX && snakeY[0] == foodY)
                {
                    // Increase the score
                    score++;

                    // Increase the snake length
                    snakeLength++;
                    Array.Resize(ref snakeX, snakeLength);
                    Array.Resize(ref snakeY, snakeLength);
                    snakeX[snakeLength - 1] = snakeX[snakeLength - 2];
                    snakeY[snakeLength - 1] = snakeY[snakeLength - 2];

                    // Generate new food
                    while (true)
                    {
                        foodX = random.Next(0, boardWidth);
                        foodY = random.Next(0, boardHeight);
                        if (board[foodX, foodY] == ' ')
                        {
                            break;
                        }
                    }
                }

                // Update the board
                board[foodX, foodY] = 'F';
                for (int i = 0; i < snakeLength; i++)
                {
                    board[snakeX[i], snakeY[i]] = 'S';
                }
            }

            // Game over
            Console.Clear();
            Console.WriteLine("Game Over!");
            Console.WriteLine("Score: " + score);
            Console.ReadKey();
        }
    }
}
קוד

תיהנה!!!

[יעקב מ. פינס]

@בוגאטי
איך מפעילים את הקוד הזה? בלי תוכנה

[בוגאטי]

@יעקב-מ-פינס ע"י קומפיילר אונליין כמו זה.
תדביק הכל בחלון השחור ותלחץ על RUN (הכפתור הירוק) כדי להריץ.

[מויטיו]

מישהו יכול לבדוק אם הקוד הזה עובד (הוא כתב לי גם תיעוד)

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class SnakeGame extends JPanel implements Runnable, KeyListener {

    private static final long serialVersionUID = 1L;

    public static final int WIDTH = 400;
    public static final int HEIGHT = 400;
    public static final int SCALE = 20;
    public static final int SPEED = 5;

    private Thread thread;
    private boolean running;

    private BodyPart b;
    private ArrayList<BodyPart> snake;

    private Apple apple;
    private ArrayList<Apple> apples;

    private Random random;

    private int xCoor = 10, yCoor = 10;
    private int size = 5;

    private boolean right = true, left = false, up = false, down = false;

    private int ticks = 0;

    public SnakeGame() {
        setPreferredSize(new Dimension(WIDTH, HEIGHT));
        addKeyListener(this);
        setFocusable(true);

        snake = new ArrayList<BodyPart>();
        apples = new ArrayList<Apple>();

        random = new Random();

        start();
    }

    public void start() {
        running = true;
        thread = new Thread(this);
        thread.start();
    }

    public void stop() {
        running = false;
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void tick() {
        if (snake.size() == 0) {
            b = new BodyPart(xCoor, yCoor, 10);
            snake.add(b);
        }

        ticks++;

        if (ticks > 250000) {
            if (right) xCoor++;
            if (left) xCoor--;
            if (up) yCoor--;
            if (down) yCoor++;

            ticks = 0;

            b = new BodyPart(xCoor, yCoor, 10);
            snake.add(b);

            if (snake.size() > size) {
                snake.remove(0);
            }
        }

        if (apples.size() == 0) {
            int xCoor = random.nextInt(39);
            int yCoor = random.nextInt(39);

            apple = new Apple(xCoor, yCoor, 10);
            apples.add(apple);
        }

        for (int i = 0; i < apples.size(); i++) {
            if (xCoor == apples.get(i).getxCoor() && yCoor == apples.get(i).getyCoor()) {
                size++;
                apples.remove(i);
                i--;
            }
        }