python un réseau de neurone peut t'il s'adapter ?

Bonjour, je m’intéresse de plus en plus aux réseaux de neurones et il y’a une question que je me pose sur l’adaptabilité de l’ia. Actuellement, tous les exemples reposes sur des jeux de données de même taille l’exemple qui reviens souvent et celui du calcule binaire : [0,0,1]=0 [1,1,1]=1 [0,1,1]=1 combien fait : [0,1,1]

Cette exemple exprime mon probleme. Le jeu de donné et toujours constitué de 3 inputs et de 1 outpouts. Mais le réseau de neurone peut il supporter des inputs de différente taille ? par exemple [1,1] ou [0,0]

l’algo peut t’il s’adapter a une taille variable des données ?

le code correspondant à l’exemple !

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

from numpy import exp, array, random, dot


class NeuralNetwork():
    def __init__(self):
        random.seed(1)
        self.synaptic_weights = 2 * random.random((3, 1)) - 1

    def __sigmoid(self, x):
        return 1 / (1 + exp(-x))

    def __sigmoid_derivative(self, x):
        return x * (1 - x)

    def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):
        for iteration in range(number_of_training_iterations):
            output = self.think(training_set_inputs)
            error = training_set_outputs - output
            adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))

            self.synaptic_weights += adjustment

    def think(self, inputs):
        return self.__sigmoid(dot(inputs, self.synaptic_weights))


if __name__ == "__main__":
    neural_network = NeuralNetwork()

    print("Random starting synaptic weights: ")
    print(neural_network.synaptic_weights)

    training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
    training_set_outputs = array([[0, 1, 1, 0]]).T

    neural_network.train(training_set_inputs, training_set_outputs, 10000)

    print("New synaptic weights after training: ")
    print(neural_network.synaptic_weights)

    print("Considering new situation [1, 0, 0] -> ?: ")
    print(neural_network.think(array([1, 0, 0])))

dernière remarque, le programme ne donne pas la solution 0 ou 1 mais une tendance, à la fin il donne comme résultat 0.99 la aussi je voudrais savoir si c’était une propriété propre au réseau de neurone de donner une tendance au lieu d’une réponse exacte, (en l’occurrence 1) ?

Pour une taille d’entrée variable, tu peux jeter un œil aux réseaux récurrents (RNN).

http://karpathy.github.io/2015/05/21/rnn-effectiveness/

les exemples que je trouve sont dans le meme style, c’est toujours le meme nombre d’input, par exemple 2 input et 1 output, cela ne peut etre variable par exemple ici avec l’addition binnaire :https://iamtrask.github.io/2015/11/15/anyone-can-code-lstm/

je vous explique mon problème, il s’agit de trouver la meilleur combinaison de caracteristique pour chauffer une maison. mes inputs sont par exemple bonne isolation, fenetre ouverte… mes outputs sont la température de la maison

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

 """
    0 fenetre ouverte
    1 fenetre fermer

    2 chauffage eau
    3 chauffage solaire
    4 chauffage bois
    5 chauffage fuel

    6 mauvaise isolation
    7 bonne isolation
    """

    inputs = array([[0, 2, 6], [1, 4, 6], [1, 5, 7], [0, 3, 7], [0, 2], [7]]) # combinaison des elements
    outputs = array([[8, 10, 11, 9, 8, 11]]).T # temperature de la maison en combinant les resultats
    question=array([0, 4, 7]) # quelle temperature donne la combinaison des elements 0,4 et 7 ?

le probleme c’est que j’aimerais combiner un nombre variable de caractéristique, par exemple 0,2,6 ou 0,2 ou seulement 7 par exemple

je sais pas si c’est plus clair ?

Bonjour, cela est impossible à réaliser car il faut utiliser la fonction dot de numpy, de la multiplication matriciel, hors on ne peut multiplier des matrices que si elles ont la mêmes taille.

La remarque sur la multiplication matricielle est juste mais la conclusion me parait fausse.

@robert003, connais-tu l’ensemble des caractéristiques possibles ? Le cas échéant, tu peux utiliser un encodage dit one-hot : un $1$ si la feature est présente, $0$ sinon. Par exemple, $[0, 2, 6]$ deviendrait $[1, 0, 1, 0, 0, 0, 1, 0]$.

vayel, ton idée est très intéressante ! (je n’y avais pas pensé) je vais regarder cela de plus pres

La réponse de @Vayel est celle qui te correspond, néanmoins pour l’info, si tu veux réellement utiliser d’autres nombres que 0/1, ce serait plutôt pour des données brute (comme une température ou une longueur) et dans ce cas là on utilise une normalisation des données.

En gros tu choisis une plage de données (ex: 500-1000) et tu la reporte sur la plage 0-1 (ex: pour 500->0 et 1000->1). Et par exemple, si tu a 0.5 en output, ça équivaut au milieu de ta plage (0.5->750 pour la plage 500-1000).

Bref si tu veux en savoir plus : ftp://ftp.sas.com/pub/neural/FAQ2.html#A_std

Personnellement, j’ajouterai que j’ai du mal à voir ton but ? Est-ce juste de t’amuser ? Parce que sinon, pour la thermique, y a des logiciels pro pour, et ils sont un poil complexes à recoder à mon avis.