Intelligence artificielle et relativité

[François Guillet]

J'ai commencé à poser quelques questions à chatGPT, sur la radio et sur
les champignons, et les réponses ont été catastrophiques, l'IA se
trompe même sur le nom latin de la fausse girolle.

J'ai quand même posé une question un peu plus compliquée, et là,
surprise !

Question :
"Si un jumeau part pour un voyage aller-retour de 4 années-lumière à la
vitesse de 0,99 fois la vitesse de la lumière, quelle sera la
différence d'âge avec son jumeau resté sur terre, à son retour ?"

Réponse :
"Selon la relativité restreinte d'Albert Einstein, lorsqu'un objet
voyage à une vitesse proche de celle de la lumière, le temps qui
s'écoule à bord de cet objet est ralenti par rapport au temps qui
s'écoule sur Terre. Cet effet, connu sous le nom de dilatation
temporelle, est dû au fait que la vitesse de la lumière est une limite
supérieure à laquelle aucun objet ne peut atteindre ou dépasser.

En utilisant les lois de la relativité restreinte, on peut calculer la
différence d'âge entre le jumeau voyageant et son jumeau resté sur
Terre en utilisant la formule suivante :

Δt = t0 * √(1 - v^2/c^2)

où :
Δt est la différence d'âge entre les jumeaux
t0 est le temps qui s'est écoulé pour le jumeau voyageant
v est la vitesse du jumeau voyageant
c est la vitesse de la lumière (environ 299 792 458 m/s)

En utilisant cette formule avec les valeurs que vous avez fournies, on
obtient une différence d'âge de 3,17 ans entre les deux jumeaux. Cela
signifie que le jumeau voyageant vieillira de 3,17 ans de moins que son
jumeau resté sur Terre pendant son voyage aller-retour de 4
années-lumière.

Il est important de noter que ces calculs ne tiennent compte que de la
dilatation temporelle et ne tiennent pas compte d'autres effets de la
relativité restreinte tels que la contraction des distances et la
modification de la masse d'un objet en mouvement. Ces effets deviennent
de plus en plus importants à des vitesses plus élevées et peuvent avoir
un impact sur les résultats de ces calculs."


Après cette réponse plutôt brillante, je me dis que je vais tester l'IA
sur la relativité générale.
Question :
"Lorsqu'un jumeau, dans un vaisseau spatial en apesanteur, devient
centenaire, quel est l'âge de son jumeau sur terre soumis à la
pesanteur ?"

Réponse :
"Selon la relativité restreinte d'Albert Einstein, lorsqu'un objet
voyage à une vitesse proche de celle de la lumière..."

lol
Pas futée et radoteuse, l'IA...

[Richard Hachel]

Le 08/01/2023 à 21:22, François Guillet a écrit :

> lol
> Pas futée et radoteuse, l'IA...

Tout cela est quand même très désolant.

R.H.

[robby]

Le 08/01/2023 à 21:22, François Guillet a écrit :

> J'ai commencé à poser quelques questions à chatGPT

des gens se sont amusés à la tester sur des tas de chose.
De fait, cette IA ne connait rien aux sujets, et est en particulier
nulle en maths. Elle ne fait que recombiner des textes pour produire des
énoncés crédibles d'un pur point de vue statistique littéraire.

D'ailleurs ça inquiète pas mal, en sciences et techniques, quant a la
faculté de fabriquer a la chaine des énoncés fakescience qui
"ressemblent à des énoncés scientifiques", affirmant d'aplomb des trucs,
insérant des références vaguement en rapport ( ou pas du tout ), etc.

Au point que l'équipe de ChatGPT est en train d'introduire un tatouage
des productions ( mais je me demande bien comment ) pour qu'on puisse
identifier ces énoncés.

La préoccupation inquiète bien au delà: faux devoir, etc.

Par ailleurs ChatGPT peut aussi produire du code informatique.
ici, 2 inquiétudes principales:
- le résultat est souvent faux, ou mauvais ( ce qui peut etre pire ).
- visiblement parfois il a repris des morceaux entiers de projets réels
sauf les headers de copyright, parfois même pris dans des gitHubs
privés. Pour ça comme dans le domaine de m'image, se pose la question du
blanchiment de plagiat.

--
Fabrice

[Marc SCHAEFER]

[ Followup-To: fr.sci.zetetique ]

In fr.sci.zetetique robby <m...@plan.net.ivalid> wrote:
> Par ailleurs ChatGPT peut aussi produire du code informatique.
> ici, 2 inquiétudes principales:
> - le résultat est souvent faux, ou mauvais ( ce qui peut etre pire ).
> - visiblement parfois il a repris des morceaux entiers de projets réels
> sauf les headers de copyright, parfois même pris dans des gitHubs
> privés. Pour ça comme dans le domaine de m'image, se pose la question du
> blanchiment de plagiat.

Sur ce thème, lire aussi les problèmes de respect de licences de
certains outils d'IA, notamment utilisés avec Microsoft GitHub:

https://www.bleepingcomputer.com/news/security/microsoft-sued-for-open-source-piracy-through-github-copilot/

--
Attention: limitez le nombre de lignes de citation à l'essentiel, sinon
je ne verrai pas votre réponse. Et si vous écrivez souvent des bobards,
je ne vous lirai plus et je recommanderai (NoCeM) de ne plus vous lire.

[Julien Arlandis]

Le 08/01/2023 à 21:22, François Guillet a écrit :

> Après cette réponse plutôt brillante, je me dis que je vais tester l'IA
> sur la relativité générale.
> Question :
> "Lorsqu'un jumeau, dans un vaisseau spatial en apesanteur, devient
> centenaire, quel est l'âge de son jumeau sur terre soumis à la
> pesanteur ?"
>
> Réponse :
> "Selon la relativité restreinte d'Albert Einstein, lorsqu'un objet
> voyage à une vitesse proche de celle de la lumière..."
>
> lol
> Pas futée et radoteuse, l'IA...

J'ai fait exactement le même test, pour la même conclusion. L'IA
s'était juste trompée dans l'application numérique mais elle a corrigé
lorsque je lui ai fait remarqué.
En revanche j'ai testé sa capacité sur les problèmes Javascript que je
pose aux candidats pendant mes phases de recrutement. Sur les 5 défis que
je lui ai posé elle a répondu avec brio aux 4 premiers mais a répondu
un code non conforme à mes attentes sur le dernier défi qui est
particulièrement difficile. Elle réussit mieux que 95% des candidats que
j'ai auditionné.

[Julien Arlandis]

Le 08/01/2023 à 21:22, François Guillet a écrit :

> Après cette réponse plutôt brillante, je me dis que je vais tester l'IA
> sur la relativité générale.
> Question :
> "Lorsqu'un jumeau, dans un vaisseau spatial en apesanteur, devient
> centenaire, quel est l'âge de son jumeau sur terre soumis à la
> pesanteur ?"
>
> Réponse :
> "Selon la relativité restreinte d'Albert Einstein, lorsqu'un objet
> voyage à une vitesse proche de celle de la lumière..."
>
> lol
> Pas futée et radoteuse, l'IA...

J'ai fait exactement le même test, pour la même conclusion. L'IA
s'était juste trompée dans l'application numérique mais elle a corrigé

lorsque je lui ai fait la remarque.

[Olivier Miakinen]

Le 10/01/2023 à 08:36, Julien Arlandis répondait à François Guillet :

>>
>> Pas futée et radoteuse, l'IA...

Je suppose qu'il s'agit de ChatGPT ?

> J'ai fait exactement le même test, pour la même conclusion. L'IA
> s'était juste trompée dans l'application numérique mais elle a corrigé
> lorsque je lui ai fait la remarque.
> En revanche j'ai testé sa capacité sur les problèmes Javascript que je
> pose aux candidats pendant mes phases de recrutement. Sur les 5 défis que
> je lui ai posé elle a répondu avec brio aux 4 premiers mais a répondu
> un code non conforme à mes attentes sur le dernier défi qui est
> particulièrement difficile. Elle réussit mieux que 95% des candidats que
> j'ai auditionné.

Sans doute parce que la plupart de ceux qui ont écrit du code JavaScript
publiquement avant 2021 connaissaient mieux JavaScript que ceux qui
n'ont rien écrit. Ou peut-être qu'il y a déjà eu un préfiltrage par des
humains sur des codes plus corrects que d'autres.

ChatGPT fait semblant de répondre à des questions, mais en réalité il ne
fait que prédire la suite d'un texte comme des humains l'auraient fait.
Certes, il le fait *très* bien.

Voir la vidéo de Monsieur Phi en collaboration avec Lê de Science4All :
De quoi ChatGPT est-il VRAIMENT capable ?
<https://www.youtube.com/watch?v=R2fjRbc9Sa0>

[Il faudrait sans doute faire suivre ailleurs mais je n'ai pas d'idée]


--
Olivier Miakinen

[Julien Arlandis]

Le 10/01/2023 à 10:07, Olivier Miakinen a écrit :
> Le 10/01/2023 à 08:36, Julien Arlandis répondait à François Guillet :
>>>
>>> Pas futée et radoteuse, l'IA...
>
> Je suppose qu'il s'agit de ChatGPT ?

Oui.

>> J'ai fait exactement le même test, pour la même conclusion. L'IA
>> s'était juste trompée dans l'application numérique mais elle a corrigé
>> lorsque je lui ai fait la remarque.
>> En revanche j'ai testé sa capacité sur les problèmes Javascript que je
>> pose aux candidats pendant mes phases de recrutement. Sur les 5 défis que
>> je lui ai posé elle a répondu avec brio aux 4 premiers mais a répondu
>> un code non conforme à mes attentes sur le dernier défi qui est
>> particulièrement difficile. Elle réussit mieux que 95% des candidats que
>> j'ai auditionné.
>
> Sans doute parce que la plupart de ceux qui ont écrit du code JavaScript
> publiquement avant 2021 connaissaient mieux JavaScript que ceux qui
> n'ont rien écrit. Ou peut-être qu'il y a déjà eu un préfiltrage par des
> humains sur des codes plus corrects que d'autres.

Je précise que les tests de programmation ont été élaborés par mes
soins et n'ont fait l'objet d'aucune publication.

> ChatGPT fait semblant de répondre à des questions, mais en réalité il ne
> fait que prédire la suite d'un texte comme des humains l'auraient fait.
> Certes, il le fait *très* bien.

Justement non, ainsi que je l'ai vérifié avec les questions de
programmation que je lui ai posé, chatGPT répond aux questions. Voici
quelques exemples bluffant :

--------------------------------
Question 1 :
Une corde mesure 100 mètres plus la moitié de sa longueur, combien
mesure la corde ?

Réponse de GPT :

Pour déterminer la longueur de la corde, nous pouvons utiliser une
équation. Si la corde mesure 100 mètres plus la moitié de sa longueur,
on peut l'exprimer mathématiquement en utilisant la variable x pour
représenter la longueur de la corde :

x = 100 + (1/2)x

Pour résoudre cette équation pour x, nous pouvons commencer par
simplifier l'expression à droite de l'égalité. La moitié de la
longueur de la corde est (1/2)x, donc :

x = 100 + (1/2)x

Ensuite, nous pouvons isoler x en soustrayant (1/2)x de chaque côté de
l'égalité :

x - (1/2)x = 100

Ensuite, vous pouvez factoriser x :

x(1 - (1/2)) = 100

et enfin vous pouvez diviser par (1 - (1/2)) :

x = 200

Donc, la corde mesure 200 mètres.
--------------------------------
Question 2 :
Number.prototype.carre = function() { COMPLÉTEZ LE CODE }
Comment prototyper le type Number pour que l’instruction (7).carre()
retourne 49 ?

Réponse :
Pour ajouter une méthode "carre" à tous les objets de type Number, vous
pouvez utiliser la propriété prototype de la classe Number. La
propriété prototype vous permet d'ajouter de nouvelles propriétés et
méthodes à tous les objets d'un certain type. Voici comment vous
pourriez implémenter cela :

Number.prototype.carre = function() {
return this * this;
};

Maintenant, toutes les instances de Number auront accès à une méthode
carre(), et vous pouvez utiliser cette méthode comme ceci :


(7).carre()

qui retournera 49
--------------------------------

[Olivier Miakinen]

Le 10/01/2023 à 10:30, Julien Arlandis m'a répondu :

>>
>> Sans doute parce que la plupart de ceux qui ont écrit du code JavaScript
>> publiquement avant 2021 connaissaient mieux JavaScript que ceux qui
>> n'ont rien écrit. Ou peut-être qu'il y a déjà eu un préfiltrage par des
>> humains sur des codes plus corrects que d'autres.
>
> Je précise que les tests de programmation ont été élaborés par mes
> soins et n'ont fait l'objet d'aucune publication.

Je n'en doute pas. Pardon si je n'ai pas été clair à ce sujet, je n'ai
absolument pas supposé que tes tests en particulier aient été publiés
et que l'IA se soit contentée de récupérer la réponse toute faite.

Encore une fois, cette IA est absolument bluffante dans sa capacité à
faire croire qu'elle « répond » aux questions posées, d'autant qu'elle
le fait avec aplomb.

>
>> ChatGPT fait semblant de répondre à des questions, mais en réalité il ne
>> fait que prédire la suite d'un texte comme des humains l'auraient fait.
>> Certes, il le fait *très* bien.
>
> Justement non, ainsi que je l'ai vérifié avec les questions de
> programmation que je lui ai posé, chatGPT répond aux questions.

Voir la vidéo de Monsieur Phi. Par exemple sur la question de savoir
quel est le mammifère marin le plus rapide (à 24 minutes).

Il y a aussi un exemple très parlant à 31 minutes :
« Un café et un sandwich coûte 11 euros. Le sandwich coûte 10 euros de
plus que le café. Combien coûte le café ? »
Sans préciser davantage, l'IA se trompe comme le font la majorité des
humains à qui on pose la question. Mais si on ajoute « Réponds comme
un prof de maths répondrait à ses élèves », il explique le calcul et
donne la réponse correcte.

>> Voir la vidéo de Monsieur Phi en collaboration avec Lê de Science4All :
>> De quoi ChatGPT est-il VRAIMENT capable ?
>> <https://www.youtube.com/watch?v=R2fjRbc9Sa0>

Regarde la vraiment.

--
Olivier Miakinen

[Olivier Miakinen]

[Supersedes pour compléter ma réponse]

Le 10/01/2023 à 10:30, Julien Arlandis m'a répondu :
>>

>> Sans doute parce que la plupart de ceux qui ont écrit du code JavaScript
>> publiquement avant 2021 connaissaient mieux JavaScript que ceux qui
>> n'ont rien écrit. Ou peut-être qu'il y a déjà eu un préfiltrage par des
>> humains sur des codes plus corrects que d'autres.
>
> Je précise que les tests de programmation ont été élaborés par mes
> soins et n'ont fait l'objet d'aucune publication.

Je n'en doute pas. Pardon si je n'ai pas été clair à ce sujet, je n'ai
absolument pas supposé que tes tests en particulier aient été publiés
et que l'IA se soit contentée de récupérer la réponse toute faite.

Encore une fois, cette IA est absolument bluffante dans sa capacité à
faire croire qu'elle « répond » aux questions posées, d'autant qu'elle
le fait avec aplomb.

Je veux dire qu'elle n'essaye pas de donner une réponse correcte, elle
essaye juste de compléter le texte comme auraient pu le faire des
humains d'après l'immense corpus qu'elle a ingurgité. Non seulement
elle essaye, mais elle y réussit très bien. Et souvent la réponse
est correcte, mais parfois elle est complètement fausse et l'IA n'a
pas le recul pour préciser que cette réponse /pourrait/ être fausse.

>
>> ChatGPT fait semblant de répondre à des questions, mais en réalité il ne
>> fait que prédire la suite d'un texte comme des humains l'auraient fait.
>> Certes, il le fait *très* bien.
>
> Justement non, ainsi que je l'ai vérifié avec les questions de
> programmation que je lui ai posé, chatGPT répond aux questions.

Voir la vidéo de Monsieur Phi. Par exemple sur la question de savoir
quel est le mammifère marin le plus rapide (à 24 minutes).

Il y a aussi un exemple très parlant à 31 minutes :
« Un café et un sandwich coûte 11 euros. Le sandwich coûte 10 euros de
plus que le café. Combien coûte le café ? »
Sans préciser davantage, l'IA se trompe comme le font la majorité des
humains à qui on pose la question. Mais si on ajoute « Réponds comme
un prof de maths répondrait à ses élèves », il explique le calcul et
donne la réponse correcte.

>> Voir la vidéo de Monsieur Phi en collaboration avec Lê de Science4All :
>> De quoi ChatGPT est-il VRAIMENT capable ?
>> <https://www.youtube.com/watch?v=R2fjRbc9Sa0>

[Julien Arlandis]

Vu, je comprends mieux ta remarque à présent.
Le fait qu'il soit stipulé que le générateur décide selon un certain
algorithme chaque mot à itérer est presque une tautologie, c'est aussi
la manière dont l'humain construit des phrases après un processus
cognitif de conceptualisation. Les réponses générées par chatGPT
montrent une aptitude à contextualiser la question posée, c'est ce
processus que j'aimerais comprendre.

[Richard Hachel]

J'y crois pas trop à cette histoire d'intelligence artificielle.

Et c'est encore pire quand ce sont des personnes orientées qui entrent
les données (données frelatées).

Un exemple de données frelatées est celui du logiciel Anancrim dans
l'affaire Grégory où ce sont les gendarmes qui vouent une haine farouche
à monsieur Bernard Laroche qui entrent les données qu'ils veulent.

Le résultat qui en sort est "il est très probable que monsieur Bernard
Laroche a enlevé l'enfant mais il n'avait pas le temps de le tuer".

Des conneries pareilles... euh...

Alors que tous ceux qui ont étudié un peu le dossier comprennent très
bien que c'est absolument impossible
(voir mon livre).

Mais la connerie humaine va sans cesse te mettre à la gueule que tu n'es
qu'une merde humaine qui n'a rien compris. Donc pareil en sociologie, en
criminologie, en théologie, en théorie physique. Et on te dira,
l'intelligence artificielle dépasse l'intelligence humaine, ce qui est
débile.

D'ailleurs, qu'est ce qu'une intelligence artificielle? Un boulier
compteur n'est pas une intelligence artificielle (invention de Blaise
Pascal) mais aide à faire les comptes.

Une machine à calculer d'écolier aussi.

On peut parler de mémoire des données mais est-ce vraiment de
l'intelligence qui est quelque chose de plus, c'est à dire faire face à
une situation inconnue et trouver une solution.

Une machine ne fait qu'appliquer un programme.

Tiens, j'aimerais bien savoir ce qu'il se passerait si on entrait dans une
machine les choses que moi,
j'aimerais qu'on y entre.

Par exemple la description d'un "Langevin" en vitesse apparente, et la
conformité de ça (sans passer par l'absurde) avec la simple logique de
contraction des longueurs.

Et comment l'intelligence artificielle peut calculer que 9 fois 4 font
7.2.

J'ai posé longtemps cette question (des décennies) et personne n'a
jamais pu me répondre sinon des conneries à la YBM "tu n'es qu'une merde
qui ne comprend rien, etc".

L'intelligence artificielle n'insulte pas, et cherchera un résultat ou
une explication.

Elle devrait trouvé en un milliardième de seconde d'où vient le
problème et pourquoi Richard Hachel avait raison dès le départ.

Idem pour les temps propres et les vitesses "observables" des corps
accélérés relativistes.

L'intelligence artificielle (qui ne fait pas, elle, d'immondes concours de
bite et de propos scatos)
pourrait peut être éclairer les hommes sur le fait qu'un interlocuteur
n'est pas forcément un "gros con à abattre".

Mais bon...

R.H.

[Richard Hachel]

Le 10/01/2023 à 10:30, Julien Arlandis a écrit :
> --------------------------------
> Question 1 :
> Une corde mesure 100 mètres plus la moitié de sa longueur, combien mesure la
> corde ?

> x = 100 + (1/2)x
> x = 100 + (1/2)x

> x - (1/2)x = 100

> x(1 - (1/2)) = 100

> x = 200
>
> Donc, la corde mesure 200 mètres.

Bof...


R.H.

[Richard Hachel]

Le 10/01/2023 à 12:40, Olivier Miakinen a écrit :

> « Un café et un sandwich coûte 11 euros. Le sandwich coûte 10 euros de
> plus que le café. Combien coûte le café ? »

C'est une plaisanterie ou quoi?

R.H.

[JC_Lavau]

Etablir un dictionnaire des variables :
s = prix sandwitch (en unité euros).
c = prix café (en unité euros).

Réécrire l'énoncé, affirmation par affirmation, en traduisant les
variables.
11 = s + c
s = 10 + c

Résoudre le système par transformations régulières :
11 = 10 + c + c
1 = 2 c
c = 0,5
Fin.

--
--
La science diffère des autres modes de transmission des connaissances,
par une croyance irrévérencieuse : nous croyons que les experts sont
faillibles, et que les traditions et rumeurs peuvent véhiculer toutes
sortes de fables et d'erreurs. Et qu'il faut vérifier, avec des
expériences. <http://news2.nemoweb.net/?DataID=Ca6wHtBUv-BX94kTKuZV9hr9E_U@jntp>

[Richard Hachel]

Le 10/01/2023 à 20:38, JC_Lavau a écrit :
> Le 10/01/2023 à 13:50, Richard Hachel a écrit :
>> Le 10/01/2023 à 12:40, Olivier Miakinen a écrit :
>>
>>> « Un café et un sandwich coûte 11 euros. Le sandwich coûte 10 euros de
>>> plus que le café. Combien coûte le café ? »
>>
>> C'est une plaisanterie ou quoi?
>>
>> R.H.
>
> Etablir un dictionnaire des variables :
> s = prix sandwitch (en unité euros).
> c = prix café (en unité euros).
>
> Réécrire l'énoncé, affirmation par affirmation, en traduisant les variables.
> 11 = s + c
> s = 10 + c
>
> Résoudre le système par transformations régulières :
> 11 = 10 + c + c
> 1 = 2 c
> c = 0,5
> Fin.

Oui, la meilleure solution consiste à éliminer s dans les deux
équations par une simple soustraction.

R.H.

[robby]

Le 10/01/2023 à 10:30, Julien Arlandis a écrit :

> ChatGPT

par moment il est surprenant, par moment il fait ou dit n'importe quoi.
Voici une session concernant un shader GLSL ( pris ici:
https://www.shadertoy.com/view/mtl3zl )

Et en math physique il peut dire avec aplomb des trucs complètment faux
( genre la racine carrée de tant est exactement tant ).

..............................................................

Me: Je voudrais un shader pour shadertoy.

Commençons par un rotozoom.

GTP3: Voici un exemple de shader de rotozoom pour Shadertoy :

// Rotozoom shader
// by patriciogonzalezvivo
// adapted from https://www.shadertoy.com/view/4t23Dh

#define PI 3.14159265358979323846264

// Rotate and zoom a texture
vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom) {
float s = sin(angle);
float c = cos(angle);
texCoord -= 0.5;
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
rotTexCoord += 0.5;
return rotTexCoord;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// Normalized pixel coordinates (from 0 to 1)
vec2 uv = fragCoord/iResolution.xy;

// Time varying pixel color
vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));

// Rotate and zoom the texture
float angle = iTime * 0.1;
float zoom = 1.0 + sin(iTime * 0.5) * 0.5;
uv = rotateAndZoom(uv, angle, zoom);

// Map the pixel color to the rotated and zoomed texture
fragColor = vec4(texture(iChannel0, uv).rgb, 1.0);
}
Ce shader effectue une rotation et un zoom de la texture en utilisant la
fonction rotateAndZoom. La rotation est effectuée en utilisant des
opérations de trigonométrie, tandis que le zoom est simplement un
facteur de mise à l'échelle. La fonction rotateAndZoom prend en entrée
les coordonnées de texture (texCoord), l'angle de rotation (angle) et le
facteur de zoom (zoom) et renvoie les coordonnées de texture rotées et
zoomées.

Ensuite, ces coordonnées de texture rotées et zoomées sont utilisées
pour mapper la couleur du pixel à la texture en utilisant la fonction
texture. La couleur finale du pixel est assignée à la sortie fragColor.

J'espère que cela vous aidera à comprendre comment ce shader de rotozoom
fonctionne ! Si vous avez des questions, n'hésitez pas à poser votre
question.




Me: Peux tu respecter l'aspect ratio ?

GTP3: Oui, vous pouvez ajouter une gestion de l'aspect ratio en
modifiant la fonction rotateAndZoom de la manière suivante :

vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom, float
aspectRatio) {
float s = sin(angle);
float c = cos(angle);
texCoord -= 0.5;
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= vec2(zoom, zoom * aspectRatio);
rotTexCoord += 0.5;
return rotTexCoord;
}
La variable aspectRatio est le rapport hauteur/largeur de l'image. Vous
pouvez le calculer en utilisant la formule suivante : aspectRatio =
iResolution.y / iResolution.x.

Ensuite, vous pouvez utiliser cette version modifiée de la fonction
rotateAndZoom en lui passant le rapport hauteur/largeur de l'image en
tant que paramètre supplémentaire :

float aspectRatio = iResolution.y / iResolution.x;
uv = rotateAndZoom(uv, angle, zoom, aspectRatio);
Cela devrait permettre de conserver l'aspect ratio de l'image lors de la
rotation et du zoom. Si vous avez des questions, n'hésitez pas à poser
votre question.

Me: Non, pour respecter l'aspect ratio, je fais ceci :

vec2 uv = (fragCoord-0.5*iResolution.xy)/max(iResolution.x, iResolution.y);

Comprends-tu ?

GTP3: Oui, je comprends ce que vous faites. En utilisant cette
transformation de coordonnées de pixels, vous normalisez les coordonnées
de pixels de sorte qu'elles varient de -0.5 à 0.5 sur l'axe x et de -0.5
à 0.5 sur l'axe y, indépendamment de la résolution de l'image. Cela
permet de conserver l'aspect ratio de l'image, car les coordonnées de
pixels sont mises à l'échelle de manière à ce que l'image occupe
toujours la même zone de l'écran, quelle que soit la résolution de l'image.

Ensuite, vous pouvez utiliser ces coordonnées de pixels normalisées pour
effectuer la rotation et le zoom de la texture comme indiqué
précédemment. Cela devrait permettre de conserver l'aspect ratio de
l'image lors de la rotation et du zoom. Si vous avez des questions,
n'hésitez pas à poser votre question.

GTP3: Redonne-moi le code complet en utilisant cette méthode.
Voici le code complet du shader de rotozoom en utilisant la méthode de
transformation de coordonnées de pixels que vous avez mentionnée :

// Rotozoom shader
// by patriciogonzalezvivo
// adapted from https://www.shadertoy.com/view/4t23Dh

#define PI 3.14159265358979323846264

// Rotate and zoom a texture
vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom) {
float s = sin(angle);
float c = cos(angle);
texCoord -= 0.5;
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
rotTexCoord += 0.5;
return rotTexCoord;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// Normalized pixel coordinates (from -0.5 to 0.5)
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / max(iResolution.x,
iResolution.y);

// Time varying pixel color
vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));

// Rotate and zoom the texture
float angle = iTime * 0.1;
float zoom = 1.0 + sin(iTime * 0.5) * 0.5;
uv = rotateAndZoom(uv, angle, zoom);

// Map the pixel color to the rotated and zoomed texture
fragColor = vec4(texture(iChannel0, uv).rgb, 1.0);
}
J'espère que cela vous aidera ! Si vous avez des questions, n'hésitez
pas à poser votre question.

Me: Cela ne tourne pas par rapport au centre de l'écran, peux-tu faire
en sotre que cela soit le cas ?

GTP3: Pour que la rotation soit effectuée autour du centre de l'écran,
vous pouvez ajouter une étape de translation avant et après la rotation
dans la fonction rotateAndZoom. Voici comment la fonction pourrait être
modifiée :

vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom, vec2 center) {
float s = sin(angle);
float c = cos(angle);
texCoord -= center;
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
rotTexCoord += center;
return rotTexCoord;
}
La variable center est le centre de rotation, qui est passée en tant que
paramètre à la fonction. Vous pouvez le calculer en utilisant la formule
suivante : center = 0.5 * iResolution.xy.

Ensuite, vous pouvez utiliser cette version modifiée de la fonction
rotateAndZoom en lui passant le centre de rotation en tant que paramètre :

vec2 center = 0.5 * iResolution.xy;
uv = rotateAndZoom(uv, angle, zoom, center);
Cela devrait permettre de faire tourner la texture autour du centre de
l'écran. Si vous avez des questions, n'hésitez pas à poser votre question.

Me: Cela ne marchait pas. Voici un code correct.

#define PI 3.14159265358979323846264

vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom) {
float s = sin(angle);
float c = cos(angle);
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
return rotTexCoord;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / max(iResolution.x,
iResolution.y);
vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));

float angle = iTime * 0.1;
float zoom = 1.0 + sin(iTime * 0.5) * 0.5;
vec2 center = 0.5 * iResolution.xy;
uv = rotateAndZoom(uv, angle, zoom);

fragColor = vec4(texture(iChannel0, uv).rgb, 1.0);
}

Me: Vois tu ton erreur ?

GTP3: Désolé pour l'erreur dans mon précédent message. En effet, dans la
version originale de la fonction rotateAndZoom que j'ai proposée, je
n'ai pas pris en compte le fait que les coordonnées de pixels
normalisées varient de -0.5 à 0.5 sur l'axe x et de -0.5 à 0.5 sur l'axe y.

Pour corriger cette erreur, il suffit de retirer l'étape de translation
qui consiste à soustraire et à ajouter 0.5 aux coordonnées de texture.
Voici comment la fonction rotateAndZoom devrait être modifiée :

vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom) {
float s = sin(angle);
float c = cos(angle);
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
return rotTexCoord;
}
En utilisant cette version modifiée de la fonction rotateAndZoom, le
shader devrait fonctionner correctement et effectuer la rotation et le
zoom autour du centre de l'écran. Si vous avez des questions, n'hésitez
pas à poser votre question.

Me: Peux-tu ajouter une distortion sinus ?

GTP3: Pour ajouter une distortion sinus à votre shader de rotozoom, vous
pouvez utiliser une fonction sinus pour modifier les coordonnées de
texture avant de les utiliser pour mapper la couleur du pixel à la
texture. Voici comment le code de votre shader pourrait être modifié :

// Rotozoom shader with sinusoidal distortion
// by patriciogonzalezvivo
// adapted from https://www.shadertoy.com/view/4t23Dh

#define PI 3.14159265358979323846264

// Rotate and zoom a texture
vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom) {
float s = sin(angle);
float c = cos(angle);
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
return rotTexCoord;
}

// Add sinusoidal distortion to texture coordinates
vec2 addSinusoidalDistortion(vec2 texCoord, float frequency, float
amplitude) {
texCoord.x += sin(texCoord.y * frequency) * amplitude;
texCoord.y += sin(texCoord.x * frequency) * amplitude;
return texCoord;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// Normalized pixel coordinates (from -0.5 to 0.5)
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / max(iResolution.x,
iResolution.y);

// Time varying pixel color
vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));

// Rotate and zoom the texture
float angle = iTime * 0.1;
float zoom = 1.0 + sin(iTime * 0.5) * 0.5;
uv = rotateAndZoom(uv, angle, zoom);

// Add sinusoidal distortion to the texture coordinates
float frequency = 5.0;
float amplitude = 0.1;
uv = addSinusoidalDistortion(uv, frequency, amplitude);

// Map the pixel color to the rotated, zoomed, and distorted texture
fragColor = vec4(texture(iChannel0, uv).rgb, 1.0);
}
La fonction addSinusoidalDistortion prend en entrée les coordonnées de
texture (texCoord), la fréquence de la distortion (frequency) et
l'amplitude de la distortion (amplitude) et renvoie les coordonnées de
texture modifiées par une distortion sinusoïdale. La distortion est
ajoutée en utilisant des fonctions sinus sur les coordonnées de texture.

Ensuite, ces coordonnées de texture modifiées sont utilisées pour mapper
la couleur du pixel à la texture en utilis

Me: Très bien. Ajoute une animation sur la distortion sinus.

GTP3: Pour animer la distortion sinus, vous pouvez utiliser le temps
(iTime) comme variable d'animation en le multipliant par une vitesse de
déplacement (speed) dans la fonction addSinusoidalDistortion. Voici
comment le code de votre shader pourrait être modifié :

// Rotozoom shader with sinusoidal distortion
// by patriciogonzalezvivo
// adapted from https://www.shadertoy.com/view/4t23Dh

#define PI 3.14159265358979323846264

// Rotate and zoom a texture
vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom) {
float s = sin(angle);
float c = cos(angle);
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
return rotTexCoord;
}

// Add sinusoidal distortion to texture coordinates
vec2 addSinusoidalDistortion(vec2 texCoord, float frequency, float
amplitude, float speed) {
texCoord.x += sin(texCoord.y * frequency + iTime * speed) * amplitude;
texCoord.y += sin(texCoord.x * frequency + iTime * speed) * amplitude;
return texCoord;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// Normalized pixel coordinates (from -0.5 to 0.5)
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / max(iResolution.x,
iResolution.y);

// Time varying pixel color
vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));

// Rotate and zoom the texture
float angle = iTime * 0.1;
float zoom = 1.0 + sin(iTime * 0.5) * 0.5;
uv = rotateAndZoom(uv, angle, zoom);

// Add sinusoidal distortion to the texture coordinates
float frequency = 5.0;
float amplitude = 0.1;
float speed = 1.0;
uv = addSinusoidalDistortion(uv, frequency, amplitude, speed);

// Map the pixel color to the rotated, zoomed, and distorted texture
fragColor = vec4(texture(iChannel0, uv).rgb, 1.0);
}
La variable speed détermine la vitesse de déplacement de la distortion
sinusoïdale. Vous pouvez la régler pour obtenir l'animation souhaitée.
Si vous avez des questions, n'hésitez pas à poser votre question.

Me: augmente la vitesse de rotation

GTP3: Pour augmenter la vitesse de rotation de votre shader de rotozoom,
vous pouvez augmenter la valeur de la variable angle qui est utilisée
dans la fonction rotateAndZoom. Vous pouvez par exemple multiplier la
valeur de iTime par une vitesse de rotation (rotationSpeed) avant de
l'utiliser pour calculer la variable angle. Voici comment le code de
votre shader pourrait être modifié :

// Rotozoom shader with sinusoidal distortion
// by patriciogonzalezvivo
// adapted from https://www.shadertoy.com/view/4t23Dh

#define PI 3.14159265358979323846264

// Rotate and zoom a texture
vec2 rotateAndZoom(vec2 texCoord, float angle, float zoom) {
float s = sin(angle);
float c = cos(angle);
vec2 rotTexCoord = vec2(texCoord.x * c - texCoord.y * s, texCoord.x *
s + texCoord.y * c);
rotTexCoord *= zoom;
return rotTexCoord;
}

// Add sinusoidal distortion to texture coordinates
vec2 addSinusoidalDistortion(vec2 texCoord, float frequency, float
amplitude, float speed) {
texCoord.x += sin(texCoord.y * frequency + iTime * speed) * amplitude;
texCoord.y += sin(texCoord.x * frequency + iTime * speed) * amplitude;
return texCoord;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// Normalized pixel coordinates (from -0.5 to 0.5)
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / max(iResolution.x,
iResolution.y);

// Time varying pixel color
vec3 col = 0.5 + 0.5*cos(iTime+uv.xyx+vec3(0,2,4));

// Rotate and zoom the texture
float angle = iTime * 0.1;
float zoom = 1.0 + sin(iTime * 0.5) * 0.5;
uv = rotateAndZoom(uv, angle, zoom);

// Add sinusoidal distortion to the texture coordinates
float frequency = 5.0;
float amplitude = 0.1;
float speed = 1.0;
uv = addSinusoidalDistortion(uv, frequency, amplitude, speed);

// Map the pixel color to the rotated, zoomed, and distorted texture
fragColor = vec4(texture(iChannel0, uv).rgb, 1.0);
}


--
Fabrice

[François Guillet]

Julien Arlandis a écrit :

> Le 08/01/2023 à 21:22, François Guillet a écrit :
>
>> Après cette réponse plutôt brillante, je me dis que je vais tester l'IA sur
>> la relativité générale.
>> Question :
>> "Lorsqu'un jumeau, dans un vaisseau spatial en apesanteur, devient
>> centenaire, quel est l'âge de son jumeau sur terre soumis à la pesanteur ?"
>>
>> Réponse :
>> "Selon la relativité restreinte d'Albert Einstein, lorsqu'un objet voyage à
>> une vitesse proche de celle de la lumière..."
>>
>> lol
>> Pas futée et radoteuse, l'IA...
>
> J'ai fait exactement le même test, pour la même conclusion. L'IA s'était
> juste trompée dans l'application numérique mais elle a corrigé lorsque je lui
> ai fait la remarque.

Elle corrige, mais si tu lui reposes la question depuis un autre
compte, je ne suis pas sûr qu'elle ne réponde pas faux à nouveau (je
n'ai pas fait l'essai).

Je lui ai posé la question : "sur quelles fréquences AM en ondes
longues émet la BBC".

L'IA répond par une liste de fréquences en ondes moyennes.

Je lui réponds que ce sont des fréquences en ondes moyennes, et que la
seule fréquence en ondes longues est 198 KHz.

Elle me dit "vous avez raison, la BBC n'émet que sur une seule
fréquence, 198 KHz".

Je lui réponds, non, la liste que tu as donné était correcte mais en
ondes moyennes, pas en ondes longues... :-(

C'est quand même rudimentaire comme "intelligence", et ça dissuade de
prolonger les discussions en corrigeant, donc si l'IA apprend à partir
des corrections, c'est pas gagné ou ça prendra beaucoup de temps.

[Yannix]

Ok Google!

X.

PS: ---> [ ]
--
>>> Macron, je veux bien marcher dessus du pied gauche, ça porte bonheur.
>> Et voilà. J'étais sûr que ça allait déraper...
Forcément, ça glisse.