Rainbowheart - ultimele 7 pagini

  • Ce am facut in izolare

    05-Apr-2021 20:09 - 24 vizionari

    Dupa o saptamana de studiu intensiv Rust (chiar imi place Rust) cred ca m-am super extenuat (overburden) si mi-a scazut sistemul imunitar, lasand covid-ul sa se manifeste.

    Cu doua saptamani in urma, pe 22 martie, am iesit pozitiv la testul covid. A urmat tuse intensa, stare subfebrila si frisoane 3-4 zile. Nu mi-am pierdut gustul sau mirosul, am luat medicamente (conform prescrierii) si m-am odihnit (de nevoie) cat am putut de mult.

    Pauza in izolare am inceput-o cu Mr. Robot (2015-2019), un serial recomandat de un prieten, un serial despre hackeri si lumea calculatoarelor.

    In rest am vizionat (ca intotdeauna) multe multe filme (16 ore zilnic) pe Youtube, dar de data aceasta scopul a fost doar sa treaca timpul, nu sa invat ceva, nu sa imi notez ceva, nu sa testez ceva si asta pentru ca nu puteam sta vertical mai mult de 30 de minute, boala ma trantea in pat. Simteam nevoia sa dorm si cand adormeam (noaptea) aveam cosmaruri (de la febra si de la filmele vizionate).

    Plictisit de filme despre conspiratii si desene animate (Naruto + Sasuke vs Kaguya, Boruto (fiul lui Naruto) si alte filme din Universul Naruto) am inceput sa caut mai mult filme depre programare.

    Am urmarit filme despre Python, decoratori, un film de 12 ore despre programarea in Python, numba, …

    Am revenit la Rust, si am cautat legatura RustWebAssembly: Un program scris in go (am testat anul trecut) pentru WebAssembly are 2 mega (enorm de mult), dar scris in Rust are cateva sute de k pentru ca Rust nu are runtime si este potrivit sau optimizat pentru WebAssembly.

    De ce ma intereseaza legatura RustWebAssembly? Pentru ca sunt dezvoltator de aplicatii web si majoritatea exemplelor de pe Youtube privind executia Rust in browsere web ca  WebAssembly sunt despre jocuri si jocurile sunt tare interesante, pentru ca ofera o interfata deosebita cu datele din serverul de web.

    Urmarind firul WebAssembly am ajuns la blazor, un sistem de dezvoltare (de la Microsoft) aplicatii in c# si compilate in WebAssembly.

    Nu am multe proiecte in .net, prin 2003 am inceput cu cateva teste .net, am facut o aplicatie de administrare windows, prin 2011 am extins (pentru mine, nu pentru public, nu pentru comunitate) un server privat de conquer online scris in c# si asta m-a motivat sa invat c#, prin 2017 am facut o biblioteca-interfata c# - Markem Imaje 9232 pentru un client si asta e tot = am uitat tot ce stiam in .net si c#.

    Curs Blazor, un film de 7 ore si 43 de minute, dar inca nu sunt pregatit sa folosesc .net si prefer javascript (compilat de svelte) pe partea de client, in browserul web.

    Apoi am gasit Anvil si un film numit Full-stack Web Apps with Nothing but Python, in care se pare ca aplicatiile python sunt compilate in JavaScript (folosind tehnologia Skulpt sau ceva asemanator) si discuta cu serverul de web prin Websockets – asta m-a impresionat.

    Pyodide = Python with the scientific stack, compiled to WebAssembly – film youtube - codul python este compilat si executat in browser – pare promitator.

    Dar cel mai incantat sunt de FastAPI, o biblioteca folosita la construirea de servere de web in Python, solutie asemanatoare cu serverul meu (bazat pe bottle) sau asemanatoare cu flask, dar in mod asincron (executie cooperativa, folosind corutine). Doua filme youtube: Intro to FastAPI - The Best Way to Create APIs in Python? si Building Web Apps using FastAPI and Python | Async APIs | OCR App.

    De la FastAPI am ajuns la Uvicorn si Hypercorn – doua servere de web (foarte rapide) care implementeaza protocolul ASGI (Asynchronous Server Gateway Interface).

    In tutorialul FastAPI am intalnit pydantic = posibilitatea ca programul Python sa verifice tipul datelor in timpul executiei, sa le valideze si sa emita mesaje de eroare prietenoase = un concept interesant de care nu am mai auzit pana acum.

    Realizez cat de putine stiu si cat de multe pot sa mai invat.


  • O aplicatie web in Rust

    18-Mar-2021 17:47 - 59 vizionari

    Imi place Rust!

    Am testat doua biblioteci de aplicatii-web in Rust: shio si actix-web.

    Se pare ca imi place shio mai mult si am schitat o mica aplicatie cu interfata web:

    
    extern crate shio;
    extern crate askama;
    
    use askama::Template;
    use hyper::mime;
    use shio::prelude::*;
    use std::env;
    
    // https://lib.rs/crates/rust-embed
    // e foarte tare: comprima fisierele si le stocheaza in executabil
    use rust_embed::RustEmbed;
    
    #[derive(RustEmbed)]
    #[folder = "static/"]
    #[prefix = "/static/"]
    struct Asset;
    
    #[derive(Template)]
    #[template(path = "index.tpl")]
    struct IndexTemplate {
        title: String,
        cnt: i64,
        mylist: [i32; 5],
        mylist2: [String; 3],
    }
    
    #[derive(Template)]
    #[template(path = "info.tpl")]
    struct InfoTemplate {
        title: String,
        msg: String,
    }
    
    static mut CNT: i64 = 0;
    
    fn index(_: Context) -> Result {
        unsafe {
            Response::with(IndexTemplate {
                title: String::from("The index"),
                cnt: CNT,
                mylist: [1, 11, 2, 333, 88],
                mylist2: [
                    String::from("A111"),
                    String::from("B2"),
                    String::from("C300"),
                ],
            })
        }
    }
    
    fn inc_cnt(_: Context) -> Result {
        unsafe {
            CNT = CNT + 1;
            Response::with(InfoTemplate {
                title: String::from("Inc cnt"),
                msg: format!("cnt={}", CNT),
            })
        }
    }
    
    fn set_cnt(_: Context) -> Result {
        unsafe {
            CNT = 0;
            Response::with(InfoTemplate {
                title: String::from("Reset cnt"),
                msg: format!("cnt={}", CNT),
            })
        }
    }
    
    fn static_embedded(ctx: Context) -> Response {
        let filename = ctx.path();
        let static_type: hyper::mime::Mime = match filename {
            x if x.ends_with(".css") => mime::TEXT_CSS,
            x if x.ends_with(".js") => mime::APPLICATION_JAVASCRIPT,
            x if x.ends_with(".woff") => mime::FONT_WOFF,
            x if x.ends_with(".woff2") => mime::FONT_WOFF2,
            _ => mime::TEXT_PLAIN,
        };
        println!("static type={} path={}", static_type, filename);
        let ret = Asset::get(ctx.path()).unwrap();
        unsafe {
            let text = String::from(std::str::from_utf8_unchecked(ret.as_ref()));
            Response::build()
                .status(StatusCode::Ok)
                .header(header::ContentType(static_type))
                .body(text)
        }
    }
    
    const DEFAULT_HOST: &str = "127.0.0.1:80";
    
    fn main() {
        // are 5 mega exe final
        // e un pic mai rapid decat actix
    
        for file in Asset::iter() {
            println!("{}", file.as_ref());
        }
    
        let host = env::args()
            .nth(1)
            .unwrap_or_else(|| DEFAULT_HOST.to_string());
    
        println!("Start shio webserver on {}", host);
        let mut router = shio::router::Router::new();
        router.add((Method::Get, "/", index));
        router.add((Method::Get, "/inc", inc_cnt));
        router.add((Method::Get, "/set", set_cnt));
        // routerul accepta regex in calea rutei
        router.add((Method::Get, "/static/[\\w\\W/]+", static_embedded));
        let service = Shio::new(router);
    
        service.run(host).unwrap();
    }
    
    
    

    Fisierul Cargo.toml:

    
    [package]
    name = "teste-web-embed"
    version = "0.1.0"
    authors = ["Ioan Coman"]
    edition = "2018"
    
    # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
    
    [dependencies]
    rust-embed="5.9.0"
    shio = "0.2.0"
    askama = { git = "https://github.com/mehcode/askama", features = ["with-shio"] }
    hyper = "0.11.2"
    
    
    

    In folderul proiectului se afla folderul static cu cateva fisiere css, js si bootstrap3, in total 3.10 MB si folderul templates cu index.tpl, header.tpl si info.tpl.

    Fisierul index.tpl din folderul templates:

    
    {% include "header.tpl" %}
    
    <h1>{{ title }}</h1>
    <hr>
    
    <a href="/a1">/a1</a> -
    <a href="/inc">/inc cnt</a> -
    <a href="/set">/set cnt=0</a>
    <br><br>
    
    
    cnt = {{ cnt }} -
    {% if (cnt > 10) %}
    este > 10
    {% else %}
    nu este > 10
    {% endif %}
    <br>
    
    
    <ol>
    {% for s in mylist %}
      <li>{{- loop.index0 }} --- {{ s }}</li>
    {% endfor %}
    </ol>
    
    <ol>
        {% for s in mylist2 %}
          <li>{{- loop.index0 }} --- {{ s }}</li>
        {% endfor %}
    </ol>
    
    
    

    Fisierul info.tpl din folderul templates:

    
    {% include "header.tpl" %}
    
    <h1>{{ title }}</h1>
    <hr>
    <a href="/">Home</a>
    
    <h2>{{ msg }}</h2>
    
    
    

    Fisierul header.tpl din folderul templates (si inclus de index.tpl si info.tpl) poate sa contina orice inceput valid de document html.

    
    <html>
    <!-- orice fel de cod html -->
    
    

    Folderul static este comprimat si inclus in programul executabil generat de compilatorul Rust folosind biblioteca rust-embed,

    Folderul templates este folosit de biblioteca askama la generarea de pagini web.

    Programul generat de Rust are 5.1 MB in windows.


  • Limbajul de programare Rust

    16-Mar-2021 18:28 - 60 vizionari

    Cu trei zile in urma am gasit un tutorial Rust de aproape doua ore si am realizat ce potential are acest limbaj:

    Rust este simultan rapid, robust si productiv.

    Rust este compilat si compilatorul garanteaza (prin analiza statica a codului) ca nu sunt probleme de alocare a memoriei sau de utilizare incorecta a memoriei alocate, adica programul are un comportament sigur chiar si in executia paralela.

    In Rust nu ai probleme (frecvent intalnite in C, Java si Golang) in timpul executiei de tip “null pointer exception” pentru ca nu permite compilatorul. Compilatorul Rust refuza sa construiasca un program aparent scris corect (alte limbaje il accepta), dar cu utilizare incorecta a variabilelor declarate.

    Dupa doua zile de teste pot spune ca am o solutie de conectare la un server MS SQL (4 ore m-am chinuit sa potrivesc versiunile bibliotecilor necesare si sa determin compilatorul sa imi accepte programul) dupa ce am invatat si aplicat corect notiunile de baza ale programarii in Rust:

    
    use tiberius::{AuthMethod, Client, Config, EncryptionLevel};
    use tokio::net::TcpStream;
    use tokio_util::compat::TokioAsyncWriteCompatExt;
    
    #[tokio::main]
    async fn query(query: &str, descr: &str) -> anyhow::Result<()> {
        let mut config = Config::new();
        config.host("127.0.0.1");
        config.port(1433);
        config.trust_cert();
        config.encryption(EncryptionLevel::Off);
        config.database("mydatabase");
        config.authentication(AuthMethod::sql_server("user", "password"));
        let tcp = TcpStream::connect(config.get_addr()).await?;
        tcp.set_nodelay(true)?;
    
        // To be able to use Tokio's tcp, we're using the `compat_write` from
        // the `TokioAsyncWriteCompatExt` to get a stream compatible with the
        // traits from the `futures` crate.
        let mut client = Client::connect(config, tcp.compat_write()).await?;
    
        let results = client.simple_query(query).await?.into_results().await?;
        println!("{}", descr);
    
        for val in results.iter() {
            for inner in val.iter() {
                if let Some(id) = inner.get::("id") {
                    print!("id = {} ", id);
                }
                if let Some(name) = inner.get::<&str, _>("nume") {
                    println!("name = {}", name);
                }
            }
        }
        Ok(())
    }
    
    
    fn main() {
        println!("Main cu doua interogari SQL:");
        let _ret1 = match query("SELECT id,nume FROM Linii", "Set 1:") {
            Ok(v) => v,
            Err(e) => println!("Eroare1: {}", e),
        };
        match query("SELECT id,DenumirePalet as nume FROM Produse", "Set 2:") {
            Ok(v) => v,
            Err(e) => println!("Eroare2: {}", e),
        };
    }
    
    
    
    

    Fisierul Cargo.toml:

    
    [package]
    name = "teste-sql"
    version = "0.1.0"
    authors = ["Ioan Coman"]
    edition = "2018"
    
    # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
    
    [dependencies]
    tiberius = "0.5.10"
    tokio-util = { version="0.6.4", features = ["compat"] }
    tokio = { version = "1.3", features = ["full"] }
    anyhow = "1.0.31"
    
    
    

    Astazi am testat un program Rust care porneste 600 de mii de proceduri, dar calculatorul (cu 8 giga de RAM) s-a blocat pentru 5-10 minute, in final am reusit sa opresc programul fara sa resetez calculatorul.

    Interesant este ca initial am testat si era ok in Rust cu 100 de mii de proceduri si deja testasem Golang cu proceduri simultane, Golang ocupa 5 giga de RAM la 600 de mii de proceduri.

    Dar Rust are o sintaxa un pic mai prietenoasa decat Golang si tratarea erorilor in Rust se face foarte elegant si aproape magic, in comparatie cu Golang unde aproximativ o treime din codul Golang scris trebuie sa verifice daca instructiunea anterioara s-a executat cu succes si daca nu, programatorul poate sa ignore eroarea (nu este recomandat),  sa o afiseze sau sa faca ceva util cu ea.

    Robustetea limbajului Rust il face sa fie foarte potrivit pentru construirea sistemelor de operare, a programelor utilitare si chiar a driverelor.

    Un program Rust simplu (fara sa importe biblioteci, ci doar sa afiseze ceva variabile pe ecran) ocupa 147-160 KB compilat, programul de conectare la MS SQL ocupa 3,8 MB in varianta de dezvoltare si 1,6 MB compilat cu optimizari (cargo build --release). Ca o comparatie, Golang genereaza programe executabile de cel putin 2 MB.

    Exista mai multe incercari de construire a unui sistem de operare in Rust, un exemplu este https://os.phil-opp.com/

    Cred ca urmatorul proiect il voi implementa in Rust.


  • Argumente pro Linux

    15-Mar-2021 18:27 - 64 vizionari

    Am vazut intr-un film artistic cum cineva castiga controlul asupra unui calculator la cateva secunde dupa ce introducea un stick USB si multa vreme dupa aceea (2-3 ani) am crezut ca sunt zvonuri, mituri si legende pana am vazut alt film pe Youtube.

    Tot timpul am crezut ca un calculator care are dezactivata optiunea autorun din stickuri USB sau care are un antivirus actualizat, este in siguranta, pana am vazut acest film:

    Stickul USB din film nu este un stick normal, nu este un mediu de stocare, este un microcontroler cu interfata USB care simuleaza o tastatura. Pentru ca protocolul de tastatura este standard si este deja implementat in Windows, comunicatia cu calculatorul se face rapid, nu este nevoie de instalare de drivere, calculatorul este compromis in mai putin de o secunda.

    Am realizat ca in Windows foarte greu te poti proteja de asa ceva (cu firewall enervant care te pune sa confirmi orice conexiune) si ca nici Linux nu este invincibil la acest tip de atac.

    Apoi am vazut un alt film pe Youtube: cum poti sa iti compromiti calculatorul deschizand un fisier pdf special construit.

    Intr-un serial TV cu genii (Scorpion TV Series 2014-2018), seful echipei de geniali (IQ 197) reuseste sa castige accesul fizic la birourile unei firme infectand meniul pdf (accesibil din Internet) al unui restaurant aflat in apropiere. La pauza de masa, angajatii se conecteaza pe internet, deschid meniul pdf al celui mai apropiat restaurant si geniul asteapta sa se conecteze cineva de la HR, preia controlul calculatorului HR, tipareste o legitimatie noua cu date reale si astfel reuseste sa intre in cladire.

    Am crezut ca formatul pdf este sigur si ca toate problemele de securitate au fost eliminate de multa vreme, dar acest film mi-a demonstrat cat de putine stiu:

    Metoda de atac functioneaza cu Windows XP si WIndows 7 si pentru Adobe Reader 8 si 9.

    Niciodata sa nu deschideti fisiere primite prin email (email spam = email nedorit = necunoscut), nici pdf, nici arhive, nici imagini, filme, etc.

    Probabil Linux este protejat la asa ceva, dar chiar daca nu este, pericolul de compromitere al calculatorului este mult mai mic decat in Windows datorita mecanismului de login ca non root si posibilitatea de executie a comenzilor periculoase in regim elevat cu sudo.

    Si inca un film vazut pe Youtube m-a convins sa renunt la Windows. Un film care afirma ca Windows este popular si ca este in viata datorita jocurilor, dar majoritatea jocurilor au inceput sa mearga ok pe Linux, fie nativ, fie cu programe adaptoare (Steam cu ProtonDB, Goldberg Emulator, Legendary, GameHub, Chiaki, play.it, Wine, PlayOnLinux, Lutris, CrossOver, … ) si ca declinul Windows-ului a inceput.

    Concluzia: Linux forever!


  • Svelte + Deno

    06-Feb-2021 21:15 - 133 vizionari

    TLDR: Svelte is the future of the front end and Deno is the future of server-side JavaScript.

    Imi place tare mult Svelte (un compilator de programe JavaScript) si de mai mult de sase luni il folosesc in aproape fiecare solutie software.

    Ieri mi-am amintit de Deno (creat de autorul node js cu intentia sa fie un succesor al lui node js) si am incercat sa potrivesc un proiect probabil abandonat sa functioneze cu Deno si am reusit, dar reteta nu este prea eleganta. Cred ca denofn/svelte este un proiect abandonat pentru ca documentatia este zero, nici nu merge cu ultima versiune de Deno (merge cu 1.6.1), a trebuit sa modific un pic configuratia implicita ca sa importe trei biblioteci mai vechi (versiunea curenta a bibliotecii dadea erori pentru ca dupa 3 luni s-a schimbat un pic arhitectura pachetului) si alte cateva bucati de cod care importau direct biblioteci incompatibile fara sa foloseasca abilitatea lui Deno sa importe cod dintr-o configuratie (fisierul import_map.json) – toate acestea demonstreaza ca denofn/svelte este o incercare abandonata, nedocumentata si inconsistenta.

    Dar astazi, cautand svelte printre modulele Deno oferite de terti, am gasit snel, un compilator de aplicatii Svelte construit special pentru Deno.

    Am creat un proiect snel (snel create nume_proiect), am compilat, testat si apoi adaugat cateva componente svelte create de mine cu cateva luni in urma si succes total.

    Am gasit undeva in Internet expresia “Svelte is the future of the front end and Deno is the future of server-side JavaScript.” si am inteles ca ma indrept in directia potrivita.

    Problema este ca Deno este intr-un proces intens de dezvoltare si de restructurare si am observat ca versiunile, chiar si minore sau consecutive, sunt inconsistente si incompatibile una cu alta.

    Dar dupa 6 luni (sunt incepator in NodeJS si il utilizez doar de dragul pachetului Svelte) de utilizare NodeJS, cred ca merita sa investesc timp si experienta in Deno.


  • Testare GPT2 in Google Colab

    03-Feb-2021 15:04 - 136 vizionari

    Google ofera resurse gratuite de calcul in Google Colab pentru studenti, savanti, cercetatori, programatori in domeniul inteligentei artificiale, …

    De ceva timp testez puterea de calcul oferita gratuit de Google in cateva proiecte AI cu BERT si GPT2.

    Documentul editat in Google Colab contine cod care se executa intr-o masina virtuala din reteaua Google si rezultatul imi apare pe calculatorul personal.

    Practic profit de resursele Google sa imi testez aplicatiile care necesita multa viteza de calcul si multa memorie si care nu pot sa ruleze pe calculatorul personal. Google Colab este un fel de JupyterLab executat in reteaua Google.

    O masina virtuala Google Colab: Tesla P100 GPU cu14-16 giga RAM si harddisk de 70 giga:

    Tesla P100 GPU cu masina virtuala de 14-16 giga RAM si harddisk de 70 giga

    Bineinteles ca odata (din greseala) am epuizat resursele de calcul incarcand in memorie un model AI de 6.55 giga (modelul numit ctrl):

    (Modelele AI testate pana acum aveau 13 mega (google/electra-small-generator), 104 mega (bert-base-uncased)  si cel mult 1.5 giga (bert-large-uncased) = marime folder cu definitiile retelei neuronale, si toate se descurcau aproape perfect in 8 giga de RAM.)

    Your session crashed after using all available RAM 

    De cele mai multe ori am nimerit Tesla K80 (costa $500) sau Tesla P100 GPU (costa $2800) ca placa grafica, dar acum am avut acces la Tesla T4, o placa de $2400.

    Collab - Linux cu Tesla T4

    Am gasit un exemplu foarte interesant in care modelul GPT2 se antreneaza pentru generarea de texte prelucrand toate textele dintr-o limba anume oferite de Wikipedia.

    Initial am testat programul de prelucrare texte in GPT2 pe calculatorul de acasa, un laptop cu procesor I5 de 5W si 8 giga de RAM, adica un sistem de calcul excelent pentru programare in general, dar nepotrivit pentru aplicatii de inteligenta artificiala:

    2000 de fisiere in 10 epoch = 184484 secunde  = 51 ore

    Prelucrarea a 2000 de fisiere in 10 repetitii (epoch) a durat 184484 secunde, adica 51 de ore.

    In Google Colab pot executa documentul timp de cel mult 12 ore si la finalul celor 12 ore (sau mai repede daca nu se executa calcule) pierd tot, asa ca trebuie sa planific calculul (antrenarea sau invatarea AI), apoi salvarea modelului AI pe hard diskul masinii virtuale urmata de copierea lui pe Google Drive. Documentul Google Colab se deconecteaza (si se pierd toata datele calculate, dar nu si documentul Colab) daca nu este folosita puterea de calcul din motive de eficienta: multi utilizatori sunt conectati si profita de resursele Google si este un mare pacat sa fiu conectat si sa tin sistemul ocupat fara sa-l folosesc.

    Asa ca am rulat, timp de cateva ore si cu multa atentie, calculele in Google Colab si am obtinut prelucrarea a 1000 de fisiere in 10 repetitii in 2661 secunde = 0.74 ore.

    1000 de fisiere in 10 epoch = 2661 secunde = 0.74 ore

    Rezulta ca laptopul meu este de 35 de ori mai lent decat Google Colab.

    Salvarea modelului pe disk si Google Drive:

    colab06

    Solutia de salvare model pe harddisk si copiere in Google Drive o am dintr-un film:

    Si documentul Google Collab asociat cu prezentarea din film este aici.

    Am multe teste cu generatoare de text in BERT si GPT2, dar nici unul nu merita publicat pentru ca mai am multe de invatat.


  • Evaluare GPT-3

    15-Jan-2021 18:42 - 181 vizionari

    Categorie: AI.

    GPT-3 este mare si puternic si promite multe. Am vazut mai multe filme despre GPT-3 pe Youtube si un film de patru ore mi-a atras atentia.

    Anul trecut am primit acces la interfata de evaluare GPT-3, am inceput sa fac cateva teste si deja am consumat 1,355 unitati din 300,000 alocate gratuit.

    Status free trial usage

    In evaluarea inteligentei artificiale este un test care demonstreaza clar ca NLP (Natural language processing) nu este NLU (Natural language understanding): plecand de la ideea “A house is bigger than a chair.” se cere sa se evalueze ca adevarat sau fals propozitia “Chair fit inside a house.” si inteligenta artificiala RoBERTa estimeaza ca un scaun incape intr-o casa in 25% din situatii, dar modelul Decomposable Attention + ELMo estimeaza aproape corect: 76%.

    RoBERTa estimeaza gresit  Decomposable Attention + ELMo estimeaza corect 

    Se pot face multe alte teste la Allen NLP, dar, ca sa inteleg rezultatul testului cu scaunul si casa, am ales ceva evident si AI e sigur ca A = B 99.3%, dar ca A = C 5.3%:

    RoBERTa estimeaza corect  RoBERTa estimeaza gresit

    Nici GPT-3 nu straluceste, marele davinci (cel mai performant model din grupul GPT-3) greseste la adunare pentru ca nu aduna (nu executa NLU, nu intelege ce face) ci doar recunoaste tipare, dar dupa cateva ajustari de parametri, se intampla minunea:

    davinci greseste la adunare  davinci ghiceste recunoscand sabloane

    Cand am schimbat modelul davinci cu modelul ada (cel mai mic sau slab model de test din grupul GPT-3) folosind aceeasi parametri, performantele au fost iar dezamagitoare (5-3 e de la davinci, dar incepand cu 5+4 sunt testele ada):

    ada greseste la adunare  davinci este cel mai bun model GPT-3

    Continuand testul cu casa si scaunul, davinci nu o nimereste, dar ada raspunde corect:

    davinci greseste   ada raspunde corect

    Concluzia: GPT-3 promite, dar sunt dezamagit. Pot obtine rezultate mult mai bune cu modele mai simple. Ca sa invat mai multe si mai repede in domeniul AI cred ca e mai bine daca testez cateva modele locale (existente in calculator) de cel mult 400 milioane de unitati neurale (GPT3 are 175 miliarde) ca am observat ca atat poate duce un calculator cu 8 giga de RAM.


Ultimele pagini: RSS

Alte adrese de Internet

Categorii

Istoric


Atentie: Continutul acestui server reprezinta ideile mele si acestea pot fi gresite.