zurück 1 ... 14 151617 18 19 ... 63 weiter

ChatGPT & AI

Mod/RDW

#301 BigBANG 23 Apr. 2023, 00:41
Teste es doch aus mit ChatGPT-4. Kanns am Handy nicht so leicht nutzen.

zitieren
#302 pump3 23 Apr. 2023, 00:43
Zitat von: Reichskatzler
Wobei mein Taschenrechner nicht zensiert wird.
Tatsächlich kann man mit dem Taschenrechner lustige Sachen machen.
Z.b. wenn man die Anzahl Doppelzentner des Gewichtes der fetten Ricarda (3) mit der Anzahl Buchstaben in L G B T Q (5) mit der Anzahl sexueller Orientierungen (4756621) multipliziert, dann den Taschenrechner umdreht, dann erhält man ein Toleranzwort.

Zitat von: BigBANG
Das könnte nicht weiter von der Wahrheit entfernt sein.
ChatGPT ist kein Chatbot, sondern ein neuronales Netz, dem das Wissen des Internets in Textform gefüttert wurde. Die Art der Textgenerierung basiert darauf das nächstwahrscheinlichste Wort zu generieren. Im Prinzip eine Art Autovervollständigung.
Weshalb diese Autovervollständigung in unterschiedlichsten Bereichen so intelligent ist, wissen selbst nichtmal ihre Erschaffer.

Das neuronale Netz hat Verbindungen geschaffen, die wir noch nicht verstehen können. Jeder, der behauptet, er könne diese AI eindeutig bewerten, ist ahngungslos. Aktuell kann das niemand.

Dazu kommt nun, dass man dieses neuronale Netz nicht nur für Wortgenerierung verwenden kann. Es gibt sogenannte Transformer, die es ermöglichen, Töne, Bilder, etc. in Tokens zu wandeln und diese dann wie Sprache ebenso zu autovervollständigen. Dabei kommen dann genauso erstaunlich richtige Ergebnisse heraus. Mit anderen Worten: Es handelt sich um eine technische Revolution, die alles auf den Kopf stellt.
Ja, ok. Also Taschenrechner mit Wortvervollständigung. Für Bilder.
Oh, wow.
Zitat von: Hexley
Kann mir ChatGPT sagen, wie ich folgenden Code ändern muss:
C++:
#include "wrapper.h" // #define BOOST_PYTHON_STATIC_LIB #include <boost/python.hpp> #include <boost/python/suite/indexing/vector_indexing_suite.hpp> namespace py = boost::python; class WrapperPython : public Wrapper { public: void wrapSetCallback(py::object fct) { Wrapper::setCallback( [fct](const std::vector<std::pair<std::string, int>>& items) { PyGILState_STATE gstate = PyGILState_Ensure(); fct(items); PyGILState_Release(gstate); }); } }; BOOST_PYTHON_MODULE(pycppcallable) { py::class_<std::vector<std::pair<std::string, int>>>("VectorPair") .def(py::vector_indexing_suite<std::vector<std::pair<std::string, int>>>()); py::class_<WrapperPython>("Wrapper", py::init<>()) .def("append_item", &WrapperPython::appendItem) .def("set_callback", &WrapperPython::wrapSetCallback) .def("use_callback", &WrapperPython::useCallback); }
Damit ich das Modul pycallable in folgendem Python Code nutzen kann?
Python:
#!/usr/bin/env python3 import pycppcallable if __name__ == '__main__': t = pycppcallable.Wrapper() def f(items): for k,v in items: print(f'String: {k} Id: {v}') t.append_item('Eins', 1) t.append_item('Zwei', 2) t.set_callback(f) t.use_callback()
Derzeit kriege ich nur diese Fehlermeldung:
Lösung: Haskell verwenden
zitieren
Mod/RDW
#303 BigBANG 23 Apr. 2023, 00:45
Zitat von: Hexley
Kann mir ChatGPT sagen, wie ich folgenden Code ändern muss:
C++:
#include "wrapper.h" // #define BOOST_PYTHON_STATIC_LIB #include <boost/python.hpp> #include <boost/python/suite/indexing/vector_indexing_suite.hpp> namespace py = boost::python; class WrapperPython : public Wrapper { public: void wrapSetCallback(py::object fct) { Wrapper::setCallback( [fct](const std::vector<std::pair<std::string, int>>& items) { PyGILState_STATE gstate = PyGILState_Ensure(); fct(items); PyGILState_Release(gstate); }); } }; BOOST_PYTHON_MODULE(pycppcallable) { py::class_<std::vector<std::pair<std::string, int>>>("VectorPair") .def(py::vector_indexing_suite<std::vector<std::pair<std::string, int>>>()); py::class_<WrapperPython>("Wrapper", py::init<>()) .def("append_item", &WrapperPython::appendItem) .def("set_callback", &WrapperPython::wrapSetCallback) .def("use_callback", &WrapperPython::useCallback); }
Damit ich das Modul pycallable in folgendem Python Code nutzen kann?
Python:
#!/usr/bin/env python3 import pycppcallable if __name__ == '__main__': t = pycppcallable.Wrapper() def f(items): for k,v in items: print(f'String: {k} Id: {v}') t.append_item('Eins', 1) t.append_item('Zwei', 2) t.set_callback(f) t.use_callback()
Derzeit kriege ich nur diese Fehlermeldung:
It appears that the Python binding for std:air<std::string, int> is missing in your code, and that's why you are getting the TypeError. You need to create a Python class for this C++ type to allow Boost.Python to convert it correctly.

Modify the BOOST_PYTHON_MODULE block in your C++ code to include the binding for std:air<std::string, int>:

BOOST_PYTHON_MODULE(pycppcallable)
{
py::class_<std:air<std::string, int>>("Pair")
.def_readwrite("first", &std:air<std::string, int>::first)
.def_readwrite("second", &std:air<std::string, int>::second);

py::class_<std::vector<std:air<std::string, int>>>("VectorPair")
.def(py::vector_indexing_suite<std::vector<std:air<std::string, int>>>());

py::class_<WrapperPython>("Wrapper", py::init<>())
.def("append_item", &WrapperPython::appendItem)
.def("set_callback", &WrapperPython::wrapSetCallback)
.def("use_callback", &WrapperPython::useCallback);
}

Now, the std:air<std::string, int> C++ type has a corresponding Python class named Pair. This should fix the TypeError you're encountering. After making this change, recompile the C++ code into a shared library, and try running your Python script again.
Sylvester
zitieren
#304 Karl Klammer 23 Apr. 2023, 00:46
Überzeugt bin ich wenn wir bald Mikrochips im Hirn haben und jeder Gedanke als Befehl an die KI, die mittlerweile alles kontrolliert, weiß und kann, entsandt werden kann. Sozusagen eine Aleggser 15.10 die nicht nur google vorliest und Musik abspielt sondern wirklich alles digitale bewirken kann.

zitieren
#305 Karl Klammer 23 Apr. 2023, 00:51

zitieren
Mod/RDW

#306 BigBANG 23 Apr. 2023, 00:53
Zitat von: Giovanni
Überzeugt bin ich wenn wir bald Mikrochips im Hirn haben und jeder Gedanke als Befehl an die KI, die mittlerweile alles kontrolliert, weiß und kann, entsandt werden kann. Sozusagen eine Aleggser 15.10 die nicht nur google vorliest und Musik abspielt sondern wirklich alles digitale bewirken kann.
Schau mal bei 19:27:
1 Person
zitieren

Mod/RDW

#307 Sylvester 23 Apr. 2023, 01:03

Zitat von: BigBANG

py::class_<std:

air<std::string, int>>("Pair")
.def_readwrite("first", &std:

air<std::string, int>::first)
.def_readwrite("second", &std:

air<std::string, int>::second);

Das hätte ich auch ohne Bing geschafft. Allerdings wollte ich schon ein Python-Tuple. Ich habe es in Edge probiert und er hatte mir folgendes vorgeschlagen:

Spoiler: Boost.Python Vorschlag von Bing

Code:

#include "wrapper.h"

// #define BOOST_PYTHON_STATIC_LIB
#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>

namespace py = boost::python;

// Registrieren Sie die Klasse std::pair<std::string, int>
struct StringIntPairToPythonConverter
{
    static PyObject* convert(const std::pair<std::string, int>& pair)
    {
        return py::incref(py::make_tuple(pair.first, pair.second).ptr());
    }
};

struct StringIntPairFromPythonConverter
{
    StringIntPairFromPythonConverter()
    {
        py::converter::registry::push_back(&convertible, &construct, py::type_id<std::pair<std::string, int>>());
    }

    static void* convertible(PyObject* obj_ptr)
    {
        if (!PyTuple_CheckExact(obj_ptr))
            return 0;
        if (PyTuple_Size(obj_ptr) != 2)
            return 0;
        return obj_ptr;
    }

    static void construct(PyObject* obj_ptr, py::converter::rvalue_from_python_stage1_data* data)
    {
        py::tuple tuple(py::borrowed(obj_ptr));
        std::string first = py::extract<std::string>(tuple[0]);
        int second = py::extract<int>(tuple[1]);
        void* storage = ((py::converter::rvalue_from_python_storage<std::pair<std::string, int>>*)data)->storage.bytes;
        new (storage) std::pair<std::string, int>(first, second);
        data->convertible = storage;
    }
};

class WrapperPython : public Wrapper
{
public:
    void wrapSetCallback(py::object fct)
    {
        Wrapper::setCallback(
            [fct](const std::vector<std::pair<std::string, int>>& items)
            {
                PyGILState_STATE gstate = PyGILState_Ensure();
                fct(items);
                PyGILState_Release(gstate);
            });
    }
};

BOOST_PYTHON_MODULE(pycppcallable)
{
    // Registrieren Sie die Konverter
    py::to_python_converter<std::pair<std::string, int>, StringIntPairToPythonConverter>();
    StringIntPairFromPythonConverter();

    py::class_<std::vector<std::pair<std::string, int>>>("VectorPair")
        .def(py::vector_indexing_suite<std::vector<std::pair<std::string, int>>>());

    py::class_<WrapperPython>("Wrapper", py::init<>())
        .def("append_item", &WrapperPython::appendItem)
        .def("set_callback", &WrapperPython::wrapSetCallback)
        .def("use_callback", &WrapperPython::useCallback);
}

Es funktioniert leider noch nicht, und so ein ähnliches Beispiel habe ich bereits auf Stackoverflow gefunden:

How to expose std::pair to python using boost::python?

Es ist witzig dass dein Lösungsvorschlag auch eine Antwort auf diesselbe Stackoverflowfrage war wie mein Lösungsvorschlag.

1 Person

zitieren

#308 Karl Klammer 23 Apr. 2023, 01:08
Zitat von: BigBANG
Schau mal bei 19:27:
Die gezeigten Beispiele der verarbeiteten fMRIs entsprechen in der Übereinstimmung zum Ausgangsmaterial in etwa dem, was ich mir visuell vorstelle und dem, was dall-e anhand einer textlichen Beschreibung dessen ausspuckt.

zitieren

#309 GеIöschtеs Mitglied 40210 23 Apr. 2023, 01:29

Zitat von: Hexley