code source réseau de neurone à n couches ?

luckytoyn · Le 12/04/2007, à 14:58

Salut tout le monde !

Je suis en thèse de physique et je me suis demandé si un réseau de neurone un peu balaise pourrait me filer un petit coup de main. J'ai donc commencé par écrire un code à 2 (*n) neurones, mais il n'apprend pas parfaitement ce que je veux... (j'essaye de lui faire faire de la simulation numérique 2D (mécanique des fluides...))
J'ai alors écrit un bash qui écrit un réseau de neurones (fortran) à N (*n) couches. (oui, je sais, ça aurait été bien mieux en C++ mais mes collègues bossent tous en fortran alors j'ai du laisser un peu tomber le C)

Malheureusement, le réseau refuse de rétrodiffuser l'erreur de façon à s'optimiser et je sêche un peu ...
Ne connaissant pas de spécialiste des neurones, je me tourne vers vous tous.

Qu'en pensez vous ?

Voulez vous le code source pour y regarder de plus près ?

Chaussette · Le 12/04/2007, à 15:34

Ca à l' air bien serré comme problème .
Je ne doute pas qu' ici il y ai des personnes pouvant t' aider mais sur développez tu aurais plus de chances de trouver un expert.

Dernière modification par Chaussette (Le 12/04/2007, à 15:34)

luckytoyn · Le 12/04/2007, à 16:57

Merci bien, ça fait longtemps que j'écume leur site (absolument merveilleux, il faut bien le dire), mais je voulais juste signaler à la communauté ubuntu que je donne le code dès qu'il est fini (je vais bien finir par débloquer le tout).

A plus

bob_rikard · Le 12/04/2007, à 17:16

luckytoyn a écrit :

Malheureusement, le réseau refuse de rétrodiffuser l'erreur de façon à s'optimiser et je sêche un peu ...
Ne connaissant pas de spécialiste des neurones, je me tourne vers vous tous.
Qu'en pensez vous ?
Voulez vous le code source pour y regarder de plus près ?

Oui, faudrait nous fournir certaines parties du code, sans quoi il est difficile de comprendre de quoi il retourne. Tu fais de la turbulence ?

luckytoyn · Le 12/04/2007, à 17:36

Non pour la turbulence.

Je fais de la convection (/diffusion) dans le manteau terrestre. Mais pour l'instant, le réseau de neurones n'a rien à voir avec tout ça. J'essaye de lui faire faire de la convection toute simple (2D) avec champ de vitesse uniforme.
Le but est de lui donner des modes (de densité) aléatoires en entrée (pour les tests, toujours le même mode) avec toujours le même champ de vitesses uniformes.

Attends, je vais faire plus clair :

Structure du réseau :
-input : un tableau de densités (cad un champ scalaire 2D)
(plus tard, je rajouterai le champ de vitesses en inputs mais je voudrais d'abord le voir converger (Erreur -> 0))
Cet input est une superposition de deux sinusoides (j'ai posé des conditions limites periodiques dont les longueurs d'ondes possibles sont quantifiées (cf. code))
-output_attendu : un autre tableau de densités calculé analytiquement.
-entre les deux : n couches de neurones basés sur des sigmoïdes.

Le programme bash prend dans le fichier "parametres" les valeurs qui importent et ecrit le code fortran : final.f90

structure du code :
- declaration des variables
- calcul des états initiaux et finaux attendus (la solution analytique qui permettra de calculer l'erreur)
/*************** en boucle
- Réponse du réseau
- Calcul de l'erreur
- rétrodiffusion de l'erreur
/***************

...

je mets le code fortran pour deux neurones :

!
MODULE par !----------------------------------------------------------------------
! Definition des parametres ecrite par le metascript
! Nombre de neurones : 2
  IMPLICIT NONE
  INTEGER,PARAMETER :: nz=10,nx=10,Nlambdamax=100,itmax=100,taille_neurones=300
  DOUBLE PRECISION, PARAMETER :: dx=1.d0,dz=1.d0,Amax=1.d0,gamma=-0.0001d0
  INTEGER :: iteration,p,q,i,j
  DOUBLE PRECISION :: phix,phiz,pi,Ax,Az,lambdax,lambdaz,dt,Ep,vx,vz
  DOUBLE PRECISION, DIMENSION(0:nx-1,0:nz-1) :: input,outan
  DOUBLE PRECISION :: ap0moy,ap1moy,ap2moy
  DOUBLE PRECISION :: rho1moy,rho2moy,rho3moy
  DOUBLE PRECISION :: sum1moy,sum2moy,sum3moy
  INTEGER :: i0,i1,i2,i3
  DOUBLE PRECISION, DIMENSION(0:nx*nz-1) :: rho0,rho3
  DOUBLE PRECISION, DIMENSION(0:taille_neurones-1) ::rho1,rho2
  DOUBLE PRECISION, DIMENSION(0:nx*nz-1,0:taille_neurones-1) :: ap0,dap0
  DOUBLE PRECISION, DIMENSION(0:taille_neurones-1,0:nx*nz-1) :: ap2,dap2
  DOUBLE PRECISION, DIMENSION(0:taille_neurones-1,0:taille_neurones-1) :: ap1,dap1
  DOUBLE PRECISION, DIMENSION(0:taille_neurones-1) :: sum1,sum2
  DOUBLE PRECISION, DIMENSION(0:nx*nz-1) :: sum3
  DOUBLE PRECISION, DIMENSION(0:taille_neurones) :: sum0_1
  DOUBLE PRECISION :: sum0_2
  DOUBLE PRECISION :: sum1_1
END MODULE par !------------------------------------------------------------------
!
!
PROGRAM nn
  !=================================================================================
  use par
  IMPLICIT NONE
  !=================================================================================
  OPEN(UNIT=95,FILE="compterendu")
  OPEN(UNIT=5,FILE="erreur")
  CALL calcul_io
  DO iteration=0,itmax
     WRITE (*,*)'iteration : ',iteration
     WRITE (95,*)''
     WRITE (95,*)'iteration : ',iteration
     CALL reponse_nn
     CALL erreur
     CALL retroerreur
  ENDDO
  CLOSE(5)
  CLOSE(95)
END PROGRAM nn
!
!
SUBROUTINE calcul_io
  !=================================================================================
  use par
  IMPLICIT NONE
  !=================================================================================
  ! Tirage aleatoire des longueurs d'onde de l'input et du champ de vitesses
  ! Egalement des amplitudes des modes
  !
  WRITE (95,*)'Subroutine calcul_io'
  WRITE (95,*)'Tirage aleatoire des parametres initiaux'
  
  pi = 3.141592653589
  phix = rand() * 2.d0 * pi
  phiz = rand() * 2.d0 * pi
  Ax = rand() * Amax
  Az = rand() * Amax
  p = int(rand()*(Nlambdamax-1))+1
  q = int(rand()*(Nlambdamax-1))+1
  lambdax = 2.d0*nx*dx / dble(p)
  lambdaz = 2.d0*nz*dz / dble(q)
  !dt = rand() * 0.1d0
  !vx = rand() !======!!!!!!!!!!========!!!!!!!!==!!! champ des vitesses !!!!
  !vy = rand()
  dt = 0.01d0
  vx = 0.01d0
  vz = 0.03d0
  !
  WRITE (95,*)'Calcul des input et outan'
  
  ! Dans cette boucle, il est facile de connecter l'eventuel input venant d'un autre code
  DO i=0,nx-1
     DO j=0,nz-1
        input(i,j) = Ax*(cos(2.d0*pi*i*dx/lambdax+phix)/2.d0+0.5d0) &
             + Az*(cos(2.d0*pi*j*dz/lambdaz+phiz)/2.d0+0.5d0)
	rho0(i+j*nx) = input(i,j)
        outan(i,j) = Ax*(cos(2.d0*pi*(i*dx-vx*dt)/lambdax+phix)/2.d0+0.5d0) &
             + Az*(cos(2.d0*pi*(j*dz-vz*dt)/lambdaz+phiz)/2.d0+0.5d0)
     ENDDO
  ENDDO
  WRITE (95,*)'Tirage aleatoire des ap* initiaux'
  ap0moy = 0.d0
  ap1moy = 0.d0
  ap2moy = 0.d0
  DO i=0,nx*nz-1
    DO j=0,taille_neurones-1
    ap0(i,j) = rand()
    ap0moy = ap0moy + ap0(i,j)
    ap2(j,i) = rand()
    ap2moy = ap2moy + ap2(j,i)
    ENDDO
  ENDDO
  DO i=0,taille_neurones-1
    DO j=0,taille_neurones-1
    ap1(i,j) = rand()
    ap1moy = ap1moy + ap1(i,j)
    ENDDO
  ENDDO
  WRITE (95,*)'Calcul des ap*moy'
  ap0moy = ap0moy / dble((taille_neurones)*(nx*nz))
  ap1moy = ap1moy / dble((taille_neurones)*(taille_neurones))
  ap2moy = ap2moy / dble((taille_neurones)*(nx*nz))
  !
    WRITE(*,*)'ap0moyen : ',ap0moy
    WRITE(*,*)'ap1moyen : ',ap1moy
    WRITE(*,*)'ap2moyen : ',ap2moy
  !
  WRITE (95,*)'Fin subroutine calcul_io'
  !
END SUBROUTINE calcul_io
!
SUBROUTINE reponse_nn ! Calcul de la reponse du reseau de neurones
  !=================================================================================
  use par
  IMPLICIT NONE
  !=================================================================================
  ! Calcul de la reponse du reseau de neurone a l'input
  ! Variables : entiers,sum5,ap0,input,rho1,sum6,ap1,rho2,output,ap2
  WRITE (95,*)'Subroutine Reponse_nn'
  !
  !____________________Calcul du nouveau rho1 (reponse de la premiere couche de neurones)
  WRITE (95,*)'Calcul de sum5 et rho1'
  !
  rho1moy = 0.d0
  sum1moy = 0.d0
  DO i1=0,taille_neurones-1
     sum1(i1) = 0.d0
     DO i0=0,nx*nz-1
        sum1(i1) = sum1(i1) + ap0(i0,i1)*rho0(i0)
     ENDDO
     sum1moy = sum1moy + sum1(i1)
     rho1(i1) = 1.d0 / (1.d0 + exp(-sum1(i1)/dble(nx*nz)))
     rho1moy = rho1moy + rho1(i1)
  ENDDO
  !
  rho2moy = 0.d0
  sum2moy = 0.d0
  DO i2=0,taille_neurones-1
     sum2(i2) = 0.d0
     DO i1=0,taille_neurones-1
        sum2(i2) = sum2(i2) + ap1(i1,i2)*rho1(i1)
     ENDDO
     sum2moy = sum2moy + sum2(i2)
     rho2(i2) = 1.d0 / (1.d0 + exp(-sum2(i2)/dble(taille_neurones)))
     rho2moy = rho2moy + rho2(i2)
  ENDDO
  !
  rho3moy = 0.d0
  sum3moy = 0.d0
  DO i3=0,nx*nz-1
     sum3(i3) = 0.d0
     DO i2=0,taille_neurones-1
        sum3(i3) = sum3(i3) + ap2(i2,i3)*rho2(i2)
     ENDDO
     sum3moy = sum3moy + sum3(i3)
     rho3(i3) = 1.d0 / (1.d0 + exp(-sum3(i3)/dble(taille_neurones)))
     rho3moy = rho3moy + rho3(i3)
  ENDDO
  !
  !____________________Calcul des moyennes
  !
  WRITE (95,*)'Calcul des moyennes des rho*moy et sum*moy puis affichage'
  !
  rho1moy = rho1moy / dble(taille_neurones)
  sum1moy = sum1moy / dble(taille_neurones*nx*nz)
  rho2moy = rho2moy / dble(taille_neurones)
  sum2moy = sum2moy / dble(taille_neurones*taille_neurones)
  rho3moy = rho3moy / dble(nx*nz)
  sum3moy = sum3moy / dble(nx*nz*taille_neurones)
  !
  WRITE (*,*)'rho1moy',rho1moy
  WRITE (*,*)'sum1moy',sum1moy
  WRITE (*,*)'rho2moy',rho2moy
  WRITE (*,*)'sum2moy',sum2moy
  WRITE (*,*)'rho3moy',rho3moy
  WRITE (*,*)'sum3moy',sum3moy
  !
  WRITE (95,*)'Fin subroutine reponse_nn'
  !
END SUBROUTINE reponse_nn
!
!
SUBROUTINE erreur ! calcul de l'erreur
  !=================================================================================
  use par
  IMPLICIT NONE
  !=================================================================================
  WRITE (95,*)'Subroutine erreur'
  !
  WRITE (95,*)'Calcul de l erreur'
  !
  Ep = 0.d0
  DO i=0,nx-1
     DO j=0,nz-1
        Ep = Ep + 0.5d0*(outan(i,j)-rho3(i+nx*j))**2
     ENDDO
  ENDDO
  !
  write(*,*)'Erreur : ',Ep
  write(5,*)'Erreur : ',Ep
  !
  WRITE (95,*)'Fin subroutine erreur'
  !
END SUBROUTINE erreur
!
!
SUBROUTINE retroerreur ! retropropagation de l'erreur
  !=================================================================================
  use par
  IMPLICIT NONE
  !=================================================================================
  WRITE (95,*)'Subroutine retroerreur'
  !
  !____________________Calcul des sum0_*
  WRITE (95,*)'Calcul des sum0_*'
  !
  sum0_2 = 0.d0
  DO i3=0,nx*nz-1
  DO i2=0,taille_neurones
  sum0_1(i2) = 0.d0
  DO i1=0,taille_neurones
    sum0_1(i2) = sum0_1(i2) + ap1(i1,i2)*rho1(i1)*(1.d0-rho1(i1))
   ENDDO
    sum0_2 = sum0_2 + ap2(i2,i3)*rho2(i2)*(1.d0-rho2(i2))*sum0_1(i2)
   ENDDO
   ENDDO
  !____________________Calcul des sum1_*
  WRITE (95,*)'Calcul des sum1_*'
  !
  sum1_1 = 0.d0
  DO i2=0,taille_neurones
  DO i1=0,taille_neurones
    sum1_1 = sum1_1 + ap2(i2,i3)*rho2(i2)*(1.d0-rho2(i2))
   ENDDO
   ENDDO
  !
  !____________________Calcul de I1 (qui contient l'erreur) :
  WRITE (95,*)'Calcul de I1 (qui contient l erreur)'
  !
  I1 = 0.d0
  DO i=0,nx-1
     DO j=0,nz-1
        I1 = I1 + rho3(i+nz*j)*(outan(i,j)-rho3(i+nz*j))*(1.d0-rho3(i+nz*j))
     ENDDO
  ENDDO
  !
  !____________________Modification des connexions
  WRITE (95,*)'Modification des connexions'
  !_______________ap0
  WRITE (95,*)'Modif de ap0'
  ap0moy = 0.d0
  DO i0=0,nx*nz-1
    DO i1=0,taille_neurones-1
       ap0(i0,i1) = ap0(i0,i1) + gamma*rho0(i0)*I1*sum0_2
       ap0moy = ap0moy + ap0(i0,i1)
    ENDDO
  ENDDO
  !_______________ap1
  WRITE (95,*)'Modif de ap1'
  ap1moy = 0.d0
  DO i1=0,taille_neurones-1
    DO i2=0,taille_neurones-1
       ap1(i1,i2) = ap1(i1,i2) + gamma*rho1(i1)*I1*sum1_1
       ap1moy = ap1moy + ap1(i1,i2)
    ENDDO
  ENDDO
  !_______________ap2
  WRITE (95,*)'Modif de ap2'
  ap2moy = 0.d0
  DO i2=0,taille_neurones-1
    DO i3=0,nx*nz-1
       ap2(i2,i3) = ap2(i2,i3) + gamma*rho2(i2)*I1
       ap2moy = ap2moy + ap2(i2,i3)
    ENDDO
  ENDDO
  !
  WRITE (95,*)'Calcul des moyennes ap*moy ... '
  ap0moy = ap0moy / (nx*nz*taille_neurones)
  ap1moy = ap1moy / (taille_neurones)**2
  ap2moy = ap2moy / (nx*nz*taille_neurones)
  WRITE (*,*)'ap0moy',ap0moy
  WRITE (*,*)'ap1moy',ap1moy
  WRITE (*,*)'ap2moy',ap2moy
  !
  !
  WRITE (95,*)'Fin subroutine retroerreur'
  !
END SUBROUTINE retroerreur

C'est un peu brutal de mettre tout le code comme ça, bon courage pour les motivés.

Salut

Dernière modification par luckytoyn (Le 12/04/2007, à 17:39)

Chaussette · Le 12/04/2007, à 18:13

[HS]
Au fait pourquoi n' avons nous pas de colorateur syntaxique dans les codes (à l' instar de developpez.net justement) ?
Ce n' est pas faisable avec PunBB ?
[/HS]

passant 01 · Le 13/04/2007, à 18:08

Je dois surement dire une c....rie mais il existe un topic sur les logiciels de Cao et de simulation
http://forum.ubuntu-fr.org/viewtopic.php?id=34186
tu trouverais pas ton bonheur la dedan ?
un logiciel aux volumes finis devrai te permetre d'avancer non ?

kritchek · Le 13/04/2007, à 18:23

Peut-être pourrais-tu coupler un algorithme génétique à ton réseau de neurones pour le faire apprendre. J'ai bosser quelques mois dans un labo d'intelligence artificielle : ça se trouve ici http://openspear.sourceforge.net/

Luckynow · Le 13/04/2007, à 19:50

Juste pour ajouter ma pierre à l'édifice, généralement les réseau de neurones à n couches ne servent pas à grand choses Normalement 3 couches sont suffisantes on peut éventuellement imaginer 1 ou 2 couches de plus.
J'avais suivis un cours à l'université de Fribourg durant lequel on a abordé les réseaux de neurones.
http://diuf.unifr.ch/courses/05-06/patr … slides.php
Une série d'exercice notamment concernait un framework java de simulation réseau de neurones, tu pourrait éventuellement voir la série en question :
http://diuf.unifr.ch/courses/05-06/patr … erie09.pdf

luckytoyn · Le 13/04/2007, à 23:13

Merci Passant 01, mais en l'occurence, si je comprends bien, ces logiciels sont utiles pour la mécanique des solides, ici, il s'agit plutôt de mécanique des fluides... Mais la liste m'intéresse de toute façon, merci bien.
kritchek, les algos génétiques, je n'y connais rien mais alors, je vais me pencher là dessus parce que ça me semble très intéressant...
Et Luckynow, je vais jeter un coup d'oeil dès ce week end, j'aimerais beaucoup voir une démo de l'inutilité des couches > 3/4 . J'ai vraiment un nombre de paramètres immense... Celà voudrait dire que ce que je veux est impossible (ou alors c'est magique).

Je sens que ce week end, je vais encore faire le geek...

Je poste des news dès que j'avance, merci !:)

Led Shark 24 kin 204 · Le 14/04/2007, à 00:23

en fait je dirais que ces logiciels servent à simuler tout un tas de choses dont des aspects
de tehrmique des solides ( calculs de fatigue, de fluage, ... )
et de mécanique des fluides, typiquement des problèmes du genre " remplissage d'un moule et refroidissment de l'aliage" ou "dynamique des écoulemnts autour d'un profil"...
en jouant sur les conditions aux limtes et les proriétés des matériaux tu devrai sortir des simulations en volumes finis potables pour ton problème...

enfin c'est mon point de vue par ce que j'ai pas bien saisi le problème...

tu travaille à quelle échelle ? sur quelles grandeurs ? avec quel niveau de détail ?
tu cherche une formule ( et je suis hors sujet ) ou des valeurs dans un plan ( et là j'ai une chance )

pour le code je peut rien faire mais je peut te tuyauter sur les méthodes éléments et volumes fins...
( enfin j'ai juste eu quleques cours dessus )

[edit 1] l'aurtokraf c'est pas mon truc après 8h de projet d'optimisation géométrique

Dernière modification par Led Shark 24 kin 204 (Le 14/04/2007, à 00:27)

luckytoyn · Le 14/04/2007, à 15:23

J'écris les simulations 2D pour la convection dans le manteau terrestre (les 3000 premiers km sous nos pieds)... Les tableaux qu'on utilise sont typiquement de l'ordre de 500x500 max. Je fais tous mes tests avec des tableaux de 100x100. Donc comme résolution, c'est de l'ordre de quelques dizaines de kilometres
Les grandeurs considérées sont : la température, les vitesses, la densité, la pression, la viscosité et la taille des grains (ça, c'est mon sujet de thèse justement). Nos travaillons également sur les coexistences de phases (cad présence éventuelle de magma) (encore un parametre donc) et la présence de différents éléments géochimiques (un domaine qui m'est totalement inconnu pour le moment, moi simple physicien qui ne reconnait pas trop un granit d'un calcaire).

Mais pour ce qui est du réseau de neurone, je veux juste lui faire avaler une convection toute simple (et de toute façon, toutes ces grandeurs sont adimensionnées dans les codes). Il n'y a donc pas de "grandeur" à considérer, mais simplement des nombres raisonnables.

Pour faire une vraie belle convection/diffusion, je bosse avec des gars qui taquinent pas mal (la plupart du temps, ca me dépasse d'ailleurs) et je teste sans arrêt de nouvelles méthodes (superbee slope limiter, eno, weno (ces deux là, je vais bientot m'y mettre), runge kutta (ordre beaucoup), semilagrangiens et blablabla...) mais toutes diffusent numériquement. Je me suis juste demandé si un système complexe autoorganisé ne pourrait pas "comprendre" pour nous un algorithme de convection non-diffusive (oui, je sais, les thèsards débutants sont pleins d'espoirs stupides ).

Les éléments finis, ça marche très bien pour la physique du solide (pour ce que j'ai pu en entendre dire) mais en méca flu, ça me semble plus compliqué à mettre en oeuvre que du eulerien. Mais bon, après, on ne sais jamais, j'ai peut être des préjugés stupides...

Led Shark 24 kin 204 · Le 15/04/2007, à 14:51

vu de ma fenètre ça ressemble beaucoup à un problème de fonderie clasique : un aligae a n phases dans un volume donné avec un flux thermique et des vitesses ( des perssions ) imposées....
ya des logiciels porpriétaires qui font ça très bien en vomlume fini on a la fraction liquide, les vistesses de chaque volume, la température la viscosité,... et tuti quanti mais j'ignore si on peut assimiler le magama à un aliage en fusion...
je ne sais pas si Salome fait ça je vais essayer de voir.

bonne continuation avec les neurones....
là je n'ais aucune compétence...

Luckynow · Le 15/04/2007, à 15:38

@luckytoyn Attention les réseaux de neurones ne vont te donner que la fonction la plus apropriée à tes échantillons. Selon les domaines d'applications l'utilisation d'échantillon d'apprentissages peut ne pas avoir de sens.(Attention au sur-apprentissage.)

luckytoyn · Le 15/04/2007, à 23:50

à Led Shark 24 kin 204,
Pour ce qui est de l'aliage à n phases, les simulations dont tu parles sont surement basées sur un algorithme de type Laudau-Ginzburg qui traite les coexistences de phases d'un point de vue énergétique (la dérivée temporelle de la densité dépend de la dérivée fonctionnelle du potentiel considéré). J'ai écrit un truc dans le genre une fois, c'est très beau. Par contre je suppose que ces logiciels doivent avoir inclus la mécanique des fluides en plus, ce qui est très intéressant.

Pour mon problème, c'est très différent parce que la coexistence de phase n'est pas "macroscopique"... Je ne dois pas voir d'océan local de magma dans ma fenêtre de simulation. Toutes ces grandeurs sont allègrement moyennées.

De toute façon, c'est un eu triste à dire mais ce qui m'importe, ce n'est pas de trouver un programme qui fait ce que je veux, c'est de l'écrire... Ce que je cherche n'existe pas à priori sinon mon directeur de thèse n'aurait pas demandé un thèsard pour faire ce job. Notre but est de tester des théories sur des simulations numériques. Utiliser un code déjà existant présuppose d'utiliser une théorie déjà connue et donc on ne fait plus de recherche
Evidemment, ce que je dis est très réducteur parce qu'on peut toujours apprendre d'un code...
De toute façon, il faut que je lise un max de programme pour me mettre à un niveau convenable, toutes vos propositions sont les bienvenues!

Pour un peu de détail, la théorie que je développe à pour but d'arriver à simuler un état autocohérent avec présence de la croute terrestre, ce qui n'a jamais été observé auparavant... J'essaye donc de rajouter ce terme en taille de grains (qui est donc moyenné, il n'y a aucun grain visible dans ma simu puisque je travaille à l'ordre de la dizaine de km...) dans les équations de conservations... En plus, je crois qu'on va être contraint d'utiliser des rhéologies non-Newtoniennes (histoire de considérer des régimes plastique dans la croute terrestre), ce qui introduit encore des non-linéarités dans le système.

Le point positif, c'est qu'il y ait une petite chance pour que le développement de "foyers de grains" éventuels puisse ressembler à des croissance de cristaux métalliques au voisinage d'une coexistence de phase... Il y a beaucoup de similitudes avec la métallurgie. Intéressant...

A luckynow
Pour ce qui est du surapprentissage, je me suis dit que le seul moyen de l'éviter, c'est d'inventer une batterie de tests très différents et successifs ; ce que je fais absolument pas pour le moment puisque je traite toujours le même cas... Quand la simple convection fonctionnera, j'essayerait de lui faire avaler également des rotations (mais alors, pour les conditions limites, je sêche totalement...) et diverses transformations compliquées (le plus compliqué possible tant qu'on connait la solution analytique). Je ne suis pas sur que ce que je demande soit faisable, mais je pense que ça vaut le coup pour la beauté du geste...

Mais pour ce qui est du surapprentissage, je n'ai pas le sentiement d'avoir très bien saisi ce que ça signifie. J'ai lu des trucs là dessus sur un lien de Wikipedia (un cours complet, bien foutu) mais je ne suis pas sur de bien cerner le fondement mathématique de la chose...

On verra bien.

Dernière modification par luckytoyn (Le 15/04/2007, à 23:51)

Led Shark 24 kin 204 · Le 16/04/2007, à 15:29

si tu dois écrire un code de calcul sur des grandeurs dynamiques dans un milieu dont la physique se raproche de celle de l'acier regarder les solutions utilisées en fonderie peut se réveler utile.
La méthode qu'emploient les logiciels tels que PamCast (proprio a licence hors de prix):

- ils divisent les dommaines d'intégration en petits cubes ( les fameux volumes finis )
- ils appliquent les équations clasiques de thremodynamique ( bernouilli ) adaptées en diférences finies auxx bornes de ces volumes finis.
typiquement on utilise df(x1,...,xn)/dxi=f(x1,...xi+-h...xn)/h +O(h) mais on peut raffiner pour avoir une bonne précision
- ils intégrent sur un pas te temps donné

le problème c'est que les grandeur caratèristiques de l'aliage sont réduites à des nuages de points en fonction d'une seule variable ( la température )
l'aventage : on obtien les températues, les vitesses, la proportion liquide / solide -> les frontières entre les domaines, les temps de refroidissment, de
remplissage, et même parait il l'état de la microstructure ( contraintes internes métalurgie ) ...

Si tu dois "creuser" dans cette direction sache que de nos jours on fait relativement bien du calcul non linéaire en méthodes numériques ( simulation de crash, flambement, plastification des structures, hydorlique non laminaire ... )
ce qui est très douloureux c'est le temps de calcul et les écarts avec les mesures : dans certains cas en fonderie on arrive tout juste à l'ordre de grandeur des volumes non remplis par l'aliage....

bref ... je continue à precher pour ma chapelle. Et je suis concient que tu dévelope dans un autre direction.

Si tu veux pluis de détails, cherche une école d'ingénieurs qui enseigne les méthodes numériques, leur prof devrai pouvoir te refiler de la matière sur laquelle plancher, et je peut aussi chercher du côté des miens mais sans garantie et pas avant deux ou trois semaines

bonne continuation.

[edit 1] pour l'influance de la croute terestre, tu dois pouvoir imposer des condions aux limites ( température, flux thermique, viscosité, taille moyenne du grain .... ) qui équivalent à sa présence bref l'integer au calcul en tant que constatne et non comme autant d'élémaents variables ( des économies de calcul ? )

Dernière modification par Led Shark 24 kin 204 (Le 16/04/2007, à 15:34)

luckytoyn · Le 16/04/2007, à 16:05

Haha ! Mais si j'impose la croute comme un condition limite, c'est de la triche ! Le but, c'est bien de retrouver la croute comme une conséquence de la dynamique interne...
La condition limite sup, c'est juste un flux froid (c'est à dire une température imposée, ce qui est plutot réaliste dans nos gammes de températures) mais ça ne suffit pas à sa présence, c'est bien ça le problème. Tout ce que je peux rajouter à la main dans les conditions serait totalement arbitraire (sur les vitesses, on impose le glissement (les montagnes n'existent pas (négligeable...)) en haut (heu partout en fait)). Il faut trouver un fichu modèle dans lequel les plaques arrivent d'elles même!

Je vais peut-être devoir me mettre à faire du maillage adaptatif d'ailleurs... J'aimerais bien en écrire un petit pour voir.

Salut !

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 12/04/2007, à 14:58

code source réseau de neurone à n couches ?

#2 Le 12/04/2007, à 15:34

Re : code source réseau de neurone à n couches ?

#3 Le 12/04/2007, à 16:57

Re : code source réseau de neurone à n couches ?

#4 Le 12/04/2007, à 17:16

Re : code source réseau de neurone à n couches ?

#5 Le 12/04/2007, à 17:36

Re : code source réseau de neurone à n couches ?

#6 Le 12/04/2007, à 18:13

Re : code source réseau de neurone à n couches ?

#7 Le 13/04/2007, à 18:08

Re : code source réseau de neurone à n couches ?

#8 Le 13/04/2007, à 18:23

Re : code source réseau de neurone à n couches ?

#9 Le 13/04/2007, à 19:50

Re : code source réseau de neurone à n couches ?

#10 Le 13/04/2007, à 23:13

Re : code source réseau de neurone à n couches ?

#11 Le 14/04/2007, à 00:23

Re : code source réseau de neurone à n couches ?

#12 Le 14/04/2007, à 15:23

Re : code source réseau de neurone à n couches ?

#13 Le 15/04/2007, à 14:51

Re : code source réseau de neurone à n couches ?

#14 Le 15/04/2007, à 15:38

Re : code source réseau de neurone à n couches ?

#15 Le 15/04/2007, à 23:50

Re : code source réseau de neurone à n couches ?

#16 Le 16/04/2007, à 15:29

Re : code source réseau de neurone à n couches ?

#17 Le 16/04/2007, à 16:05

Re : code source réseau de neurone à n couches ?

Pied de page des forums