Názory k článku
OpenAI představila GPT 4, nová éra lidstva je tu?

cesta vede sem https://www.csfd.cz/film/185578-absurdistan/prehled/

Tohle je naprosto úžasný nadčasový dokumentární film. Původně jsem si myslel, že jde o komedii, ale pak jsem se rozhlédl kolem sebe a ...

Škoda len, že tvorcovia v druhej polovici filmu načisto premrhali jeho potenciál, a spravili z toho hovadinu pre práve takých blbcov, akých tam vykreslili (trebárs ten trápne zdĺhavý súboj v aréne)....

https://www.southparkstudios.com/episodes/8byci4/south-park-deep-learning-season-26-ep-4

mimochodom tiez generovane cez AI ;)

Zadal jsem ať vytvoří GPT 5 pod GPL 3 a pošle jako balíček do repa Debianu. Zatím tam nic není takže konec světa ještě nehrozí.

A pak ještě ty váhy..

## hello, are you new version?

** Hello! Yes, I am a relatively new version of OpenAI's language model. I am based on the GPT-3 architecture and have been trained on a massive dataset of diverse text, allowing me to generate high-quality responses to a wide range of queries and prompts.

## GPT-3 is old version, isn't here already version 4?

** As of my knowledge cutoff date of September 2021, there was no public release or announcement of GPT-4 by OpenAI. The most recent version of the GPT series that has been publicly released is GPT-3. However, OpenAI is constantly working on research and development of their language models, so it is possible that a newer version has been developed since then or will be released in the future.

>>> Takže možná nová verze je, ale v tento okamžik není dostupná veřejnosti. Nebo má být jinde na jiném URL?

A nebude to tím, že v textech na kterých tu GPT-4 trénovali se ještě o žádné GPT-4 nepsalo?

A v textech na kterých trénovali GPT3 se o GPT3 psalo?

jaké verze jste ?

Jsem založen na architektuře GPT-3.5 a můj poslední známý datový řez je z roku 2021.

Tak muzeme ohrnovat nosem na kvalitou "AI". Ale to ze vnese velike zmeny i do naseho sveta je proste fakt. A musime se mu co nejdriv prizpusobit.
Coz pro nas v IT je denni chleba a neni potreba to nejak zvlast vysvetlovat.

Jediný efekt bude ještě víc balastu v prostoru a víc informačního šumu. K této technologii jsem dost skeptický - umí to jen průměrovat balastní data na netu.

Tohle je pravda. Taky nepozna jestli ma vic verit aktualnim nebo vetsinovym informacim a je velky problem s tim, ze si vzdy vymysli nejakou verohodnou odpoved, ktera je vetsinou spatna. Asi jako mizerny, nekvalifikovany novinar, prekladajici pro nejaky web clanky a zpravicky, kterym skoro vubec nerozumi (nejlepsi jsou clanky jak vydelat penize na ChatGPT, ktere vypadaji, ze ChatGPT pise)

Ale jsou situace, kdy se to fakt hodi. Ja tomu dal treba optimalizovat C++ kod pomoci AVX instrukci. Jestli byl vysledek spravny nevim, musel jsem zadani zjednodusit. Ale byl jsem podle toho schopen napsat spravny kod asi za 15 minut s jednim dotazem na google (reference avx) a nemusel resit jakou instrukci rozkopirovat 1.0f do celeho registru, jak je scitat, nasobit, kopirovat do/z pameti. Stejne tak se to hodi na to, jak napsat nejakou jednoduchou funkci s pouzitim numpy (ktere moc neznam). Ale vzdy clovek musi vicemene spravny vysledek znat a nesmi se nechat zmast tim, ze obsahuje tezko postrehnutelne chyby a dopousti se ruznych zjednoduseni.

Podle me, kdyz clovek akceptuje nedostatky, tak je to schopne generovat velmi dobre ruzne sablony, kterymi se da inspirovat (napis reseni kvadraticke rovnice v texu, vygeneruj svg obrazek dle zadani, co dela tohle makro v cmake souboru)

Je to jaka mit k ruce junior programatora. Nechas ho udelat jednoduchou praci a tu pak zkontrolujes.

Já teda nevím mě to zatím přijde jenom jako stupidní vyhledávač se zastaralými daty. Zkoušel jsem se zeptat co bude nového v Java 21 a na to mi odpověděl úplné nesmysly, že Oracle ještě nenaplánoval vydání atp. a mlel jenom o Java 17, a že další LTS verze bude v záři 2024, což není pravda. Pak jsem to zkoušel na několika známých algoritmech a aby mi dal přiklad což o to příklad to dá, ale pak ukázka a vysvětlení je třeba úplně něco jiného. Buď se blbě ptám nebo mám smůlu. Ty samé informace mi vrátí google do 5. dotazu s pěknou stránkou.

Já ho nepoužívám na místo google, ale namísto dotazu do fóra. Dostanu odpověď snáz, ve stejné kvalitě, a bez trollů.

Jenže mě tak v polovině dotazů tvrdí úplné nesmysly.

Takže stejně jako ty odpovědi ve fóru, ne? ;)

Právě, že horší, protože i když to upozorníš na totální nesmysl resp. lež, tak je to schopné zopakovat.

Kdyz cloveku zalezi na pravde tak to lze. Je to dobry jen pro kreativce kde nejsou dulezita fakt a pravdivost (novinari). Takze kde je ta "inteligence"?

Tak nejde to zobecnovat i kdyz na novinare FoxNews to plati cos napsal.

16. 3. 2023, 15:07 editováno autorem komentáře

Dneska vetsinu lidi pravda moc nezajima. Ctou si vatu. A to tahle vec umi napsat dobre, to uznavam. A tahle vec je skvela na "napis mi esej na tema X". To co jsem cetl tak je k nepoznani od cloveka. Ale kdyz se ho clovek pta na snadno overitelna fakta tak ta vec konci.

Mozno to nepouzivate spravne. Kolko programatorov vo vasom okoli zvlada aspon toto a urobi to za par sekund aj s vysvetlivkami. Medzikody som nedaval ale skutocne to generovalo kod, skuste sami:
>>> Write Java code which creates tree from item parent relationship

Here is an example of Java code that creates a tree from an array of items, where each item has a parent relationship:

import java.util.*;

class TreeNode {
    int val;
    List<TreeNode>
....

In this example, an Item class is defined with a value and a parent value. The createTree() function takes an array of Item objects as input, creates a tree node for each item, and then adds the appropriate child-parent relationships. The function returns the root node of the tree. It is also assumed that the parentVal is 0 if the item has no parent.
This is just one of the many possible ways to implement a tree from an array of items with parent relationship, It is just a basic example which can be used as a reference. More functionality or edge cases should be handled when using it in production.

>>> Now write it in typescript

Sure, here's an equivalent version of the Java code in TypeScript:

class TreeNode {
    val: number | Long;
    children: TreeNode[];
...

In this version I've also added type for val and parentVal as number | Long as it can be long or number based on the requirement. Also, in typescript, you don't need to specify the type of the variable before the constructor call like in Java, the type can be inferred by the assigned value.
As you can see, the TypeScript code is very similar to the Java version, but with a few differences in syntax and naming conventions. For example, the new keyword is not used to create instances of classes, and method names like add() and put() are replaced with push() and set(), respectively.

>>> instead of map lookup use array iteration

Sure, here's the modified version of the TypeScript code that uses array iteration instead of a Map lookup to create the tree:

class TreeNode {
    val: number | Long;
    children: TreeNode[];

    constructor(val: number | Long) {
        this.val = val;
        this.children = [];
    }
}

class Item {
    val: number | Long;
    parentVal: number | Long;

    constructor(val: number | Long, parentVal: number | Long) {
        this.val = val;
        this.parentVal = parentVal;
    }
}

function createTree(items: Item[]): TreeNode | undefined {
    // Create a array to store the tree nodes
    const nodes = new Array<TreeNode>();
    for (const item of items) {
        const node = new TreeNode(item.val);
        nodes.push(node);
    }

    // Add the child-parent relationships
    for (const item of items) {
        for (const node of nodes) {
            if (node.val === item.parentVal) {
                node.children.push(new TreeNode(item.val));
                break;
            }
        }
    }

    // Find the root node (the one with no parent)
    for (const node of nodes) {
        if (!node.children.length) {
            return node;
        }
    }
}

const items = [
    new Item(1, 0),
    new Item(2, 1),
    new Item(3, 1),
    new Item(4, 2),
    new Item(5, 4)
];
const root = createTree(items);
console.log(`Root node value: ${root?.val}`);

As you can see, I removed the use of map and replaced it with array of TreeNode, in the first loop, I created the new TreeNode instances, then in the second loop I iterated over the array nodes and checked for the matching val to parentVal of the item, when found I added the TreeNode with matching val as child. Lastly, I iterated over the nodes again to find the root node by checking if it has no children. Please note that this method will work fine with the small arrays but it will have O(n^2) time complexity which can be slow with large datasets.

Jenze na stackoverflow to mam i s hodnocenim a komentaremi.
https://stackoverflow.com/questions/19330731/tree-implementation-in-java-root-parents-and-children

Navic ten GTP nedava pokazde stejnou odpoved. A obcas je to takovy Baron Prasil. Smes faktu, polopravd a uplnych vymyslu. Jako ono to vypada hezky, ze to zabali i do textu, ale jak vite, ze si nevymysli?

Ale odpoved ktoru ste dali vy neriesi problem ktory som chcel. Vyzera ze ste nepochopili co som chcel a co ChatGPT pochopil uplne spravne. A uz vobec som nenasiel riesenie bez HashMapy.