def forward(self, X, temp, phi_prior): """ For one Monte Carlo sample :param X: [batch_size, input_dim] :return: output for one MC sample, size = [batch_size, output_dim] """ # sample weights and biases sigma_w = torch.log(1 + torch.exp(self.w_rho)) sigma_b = torch.log(1 + torch.exp(self.b_rho)) sigma_prior = torch.log(1 + torch.exp(self.rho_prior)) u_w = torch.rand(self.w_theta.shape) u_b = torch.rand(self.b_theta.shape) u_w = u_w.to(self.device) u_b = u_b.to(self.device) self.gamma_w = gumbel_softmax(self.w_theta, u_w, temp, hard=True) self.gamma_b = gumbel_softmax(self.b_theta, u_b, temp, hard=True) epsilon_w = Normal(0, 1).sample(self.w_mu.shape) epsilon_b = Normal(0, 1).sample(self.b_mu.shape) epsilon_w = epsilon_w.to(self.device) epsilon_b = epsilon_b.to(self.device) self.w = self.gamma_w * (self.w_mu + sigma_w * epsilon_w) self.b = self.gamma_b * (self.b_mu + sigma_b * epsilon_b) output = torch.mm(X, self.w) + self.b.expand(X.size()[0], self.output_dim) # record KL at sampled weight and bias w_phi = sigmoid(self.w_theta) b_phi = sigmoid(self.b_theta) kl_w = w_phi * (torch.log(w_phi) - torch.log(phi_prior)) + \ (1 - w_phi) * (torch.log(1 - w_phi) - torch.log(1 - phi_prior)) + \ w_phi * (torch.log(sigma_prior) - torch.log(sigma_w) + 0.5 * (sigma_w ** 2 + self.w_mu ** 2) / sigma_prior ** 2 - 0.5) kl_b = b_phi * (torch.log(b_phi) - torch.log(phi_prior)) + \ (1 - b_phi) * (torch.log(1 - b_phi) - torch.log(1 - phi_prior)) + \ b_phi * (torch.log(sigma_prior) - torch.log(sigma_b) + 0.5 * (sigma_b ** 2 + self.b_mu ** 2) / sigma_prior ** 2 - 0.5) self.kl = torch.sum(kl_w) + torch.sum(kl_b) return output
def costFunction(X, Y, Theta): m = X.shape[0] H = sigmoid(np.matmul(X, np.transpose(Theta))) # print(H.shape) J = -1 / m * np.sum( Y * np.log(H + 0.001) + (1 - Y) * np.log(1 - H + 0.001), axis=0) J = np.reshape(J, (Theta.shape[0], 1)) return J
def train(self, x_train, y_train): w = np.ones((x_train.shape[1], 1)) learning_rate = 0.001 for i in range(100000): h = sigmoid(np.dot(x_train, w)) error = y_train - h w = w + learning_rate * np.dot(x_train.transpose(), error) self.w = w print('系数w', self.w, self.w.shape)
def predict(self, question): """Returns probability of correct answer for given question. :param question: Asked question. :type question: :class:`pandas.Series` or :class:`Question` """ item = self.items[question.user_id, question.place_id] prediction = tools.sigmoid(item.knowledge) return self.respect_guess(prediction, question.options)
def _logistic_regression(x, weight, bias): """ 逻辑回归 :param x: input data :param weight: :param bias: :return: """ # numpy.matmul 函数返回两个数组的矩阵乘积 return tools.sigmoid(np.matmul(x, weight) + bias)
def predict(self, question): """Returns probability of correct answer for given question. :param question: Asked question. :type question: :class:`pandas.Series` or :class:`Question` """ user = self.users[question.user_id] place = self.places[question.place_id] prediction = tools.sigmoid(user.skill - place.difficulty) return self.respect_guess(prediction, question.options)
def reset(self, angles=None, p=None, noise=0, source_bandit=None): lin = np.linspace(0, self.complexity, self.precision + 1, endpoint=True) x, y = np.meshgrid(lin, lin) self.grid_data, self.angles, self.p, self.unsmoothed = perlin( x, y, angles=angles, pre_p=p, noise=noise) if self.smooth_function == 'sigmoid': self.grid_data = sigmoid(1 * self.grid_data) if self.smooth_function == 'strongsigmoid': self.grid_data = sigmoid(10 * self.grid_data) self.grid_data = normalize(self.grid_data, offset=np.min(self.grid_data), scale=np.ptp(self.grid_data)) self._value_landscape = None self.cached_contexts = None
def gradientDescent(X, Y, Theta, learninRate, numIter): m = X.shape[0] for i in range(numIter): H = sigmoid(np.matmul(X, np.transpose(Theta))) Theta = Theta - learninRate / m * np.matmul(np.transpose(H - Y), X) cost = costFunction(X, Y, Theta) if (i % 100 == 0): print(i, ":", cost) return (Theta)
def predict(theta, X): '''''Predict label using learned logistic regression parameters''' # m, n = X.shape p = np.zeros(len(X)) # print(X.dot(theta.T)) h = sigmoid(X.dot(theta.T)) # print(h) for it in range(len(h)): if h[it]>0.5: p[it]=1 else: p[it]=0 return p
def __backpropogation(self, x, y): """ Backpropogation method used with supplied input and output. Returns a tuple of gradients for weights and biases: (nabla_b, nabla_w) Each element is column vector containing gradients for the respecting layer. REF: http://neuralnetworksanddeeplearning.com/chap2.html """ # Empty matrices with bias shapes / sizes. nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] # The initial activation. activation = x # List of activations for each layer. activations = [x] # List of outputs. zs = [] # Iterating through tuples of biases and weights. for b, w in zip(self.biases, self.weights): # Calculating neuron ouput: # Dot multiplication of weight and activation, added neuron biase. z = np.dot(w, activation) + b zs.append(z) # New activation. activation = t.sigmoid(z) activations.append(activation) # Backpropogation part. delta = self.cost_function_prime(activations[-1], y) * t.sigmoid_prime( zs[-1]) nabla_b[-1] = delta nabla_w[-1] = np.dot(delta, activations[-2].transpose()) for l in xrange(2, self.number_of_layers): z = zs[-l] sp = t.sigmoid_prime(z) delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp nabla_b[-l] = delta nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose()) return (nabla_b, nabla_w)
def predict(self, question): """Returns probability of correct answer for given question. :param question: Asked question. :type question: :class:`pandas.Series` or :class:`Question` """ item = self.items[question.user_id, question.place_id] if item.any_incorrect: strength = self.memory_strength(question) else: strength = 0 prediction = tools.sigmoid(item.knowledge + strength) return self.respect_guess(prediction, question.options)
def predict(self, question): """Returns probability of correct answer for given question. :param question: Asked question. :type question: :class:`pandas.Series` or :class:`Question` """ item = self.items[question.user_id, question.place_id] knowledge = ( item.knowledge + self.gamma * len(item.correct) + self.delta * len(item.incorrect) ) return tools.sigmoid(knowledge)
def predict(self, question): """Returns probability of correct answer for given question. :param question: Asked question. :type question: :class:`pandas.Series` or :class:`Question` """ item = self.items[question.user_id, question.place_id] if item.practices: seconds = tools.time_diff(question.inserted, item.last_inserted) time_effect = self.time_effect(seconds) else: time_effect = 0 prediction = tools.sigmoid(item.knowledge + time_effect) return self.respect_guess(prediction, question.options)
def predict(self, question): """Returns probability of correct answer for given question. :param question: Asked question. :type question: :class:`pandas.Series` or :class:`Question` """ item = self.items[question.user_id, question.place_id] correct_weight, incorrect_weight = self.get_weights(item, question) knowledge = ( item.knowledge + self.gamma * correct_weight + self.delta * incorrect_weight ) prediction = tools.sigmoid(knowledge) return self.respect_guess(prediction, question.options)
def process(self, a): """ Feed forward processing of inputs. Input to the system is processed through the layers of the network, and an appropriate output is produced. a Input to the system. Should be in the form of colunm vector. Just as np.random.randn(3,1) would produces a (3x1) column vector. """ # With each step, activation of layer is updated to represent # the activation of the next layer. # For a [2,3,1] neural network. # Step 1: Input to Hidden Layer w(3x2) x a(2x1) + b(3x1) -> sigmoid -> a' (3x1) # Step 2: Hidden Layer to Output w(1x3) x a(3x1) + b(1x1) -> sigmoid -> a' which is the output. for b, w in zip(self.biases, self.weights): a = t.sigmoid(np.dot(w, a) + b) # We basically flow the information through the layers # until the output is reached. return a
def predict(self, x): wx = np.dot(x, self.w) return sigmoid(wx)
def predict(self, input): pred_1 = t.sigmoid(np.dot(input, self.weights1.T)) pred_2 = t.relu(np.dot(pred_1, self.weights2.T)) return t.relu(np.dot(pred_2, self.weights3.T))
def feedforward(self): self.layer1 = t.sigmoid(np.dot(self.input, self.weights1.T)) self.layer2 = t.relu(np.dot(self.layer1, self.weights2.T)) self.output = t.relu(np.dot(self.layer2, self.weights3.T))
one1_w = (net.l1.w != 0).float() one1_b = (net.l1.b != 0).float() one2_w = (net.l2.w != 0).float() one2_b = (net.l2.b != 0).float() one3_w = (net.l3.w != 0).float() one3_b = (net.l3.b != 0).float() one4_w = (net.l4.w != 0).float() one4_b = (net.l4.b != 0).float() sparsity = (torch.sum(one1_w) + torch.sum(one2_w) + torch.sum(one3_w) + torch.sum(one4_w) + torch.sum(one1_b) + torch.sum(one2_b) + torch.sum(one3_b) + torch.sum(one4_b)) / total print('Epoch {}, Train_Loss: {}, phi_prior: {}, sparsity: {}'.format(epoch, np.mean(train_losses), phi_prior, sparsity)) print('Finished Training') # sparsity level one1_w = (sigmoid(net.l1.w_theta) > 0.5).float() one1_b = (sigmoid(net.l1.b_theta) > 0.5).float() one2_w = (sigmoid(net.l2.w_theta) > 0.5).float() one2_b = (sigmoid(net.l2.b_theta) > 0.5).float() one3_w = (sigmoid(net.l3.w_theta) > 0.5).float() one3_b = (sigmoid(net.l3.b_theta) > 0.5).float() one4_w = (sigmoid(net.l4.w_theta) > 0.5).float() one4_b = (sigmoid(net.l4.b_theta) > 0.5).float() sparse_overall = (torch.sum(one1_w) + torch.sum(one2_w) + torch.sum(one3_w) + torch.sum(one4_w) + torch.sum(one1_b) + torch.sum(one2_b) + torch.sum(one3_b) + torch.sum(one4_b)) / total sparse_overalls.append(sparse_overall) sparse_overall2 = (torch.sum(sigmoid(net.l1.w_theta)) + torch.sum(sigmoid(net.l1.b_theta)) +\ torch.sum(sigmoid(net.l2.w_theta)) + torch.sum(sigmoid(net.l2.b_theta)) +\ torch.sum(sigmoid(net.l3.w_theta)) + torch.sum(sigmoid(net.l3.b_theta)))/total sparse_overalls2.append(sparse_overall2) torch.set_printoptions(profile="full")
for index, neuron in enumerate(network.layers[0].neurons): neuron.output = X[index] network.layers[0].add_outputs() network.layers[1].add_weights() network.layers[2].add_weights() network.layers[3].add_weights() network.layers[1].add_bias() network.layers[2].add_bias() network.layers[3].add_bias() ns_probs = [0 for _ in range(len(Y[:, 0]))] val_loss, loss, lr_val_auc, lr_auc = [], [], [], [] for i in range(epochs): ############# feedforward ### Hidden layer 1 ### z_h_1 = X.dot(network.layers[1].weights.T) + network.layers[1].bias network.layers[1].outputs = sigmoid(z_h_1) ### Hidden layer 2 ### z_h_2 = network.layers[1].outputs.dot( network.layers[2].weights.T) + network.layers[2].bias network.layers[2].outputs = sigmoid(z_h_2) ###output### z_o = np.dot(network.layers[2].outputs, network.layers[3].weights.T) + network.layers[3].bias network.layers[3].outputs = softmax(z_o) ### Backpropagation ## Output layer delta_z_o = network.layers[3].outputs - Y delta_w13 = network.layers[2].outputs dw_o = np.dot(delta_z_o.T, delta_w13) / X.shape[0] db_o = np.sum(delta_z_o, axis=0, keepdims=True) / X.shape[0] ## Hidden layer 2