What's new
By:

🎓 Academic Comment for Çℎḙḡḡ answers

Status
Not open for further replies.
https://www.Çℎḙḡḡ.com/homework-help...-would-32-256-2048-16384-25e-o-245--q59079136
hello po maam ako din po pasagot sana mapansin agad po
 
https://www.Çℎḙḡḡ.com/homework-help...-would-32-256-2048-16384-25e-o-245--q59079136
hello po maam ako din po pasagot sana mapansin agad po
 
a1 = 2^5
a2 = 2^8
a3 = 2^11

This is a GP with first number, m = 5, difference , d = 3. Lets apply the nth number formula as below :

So, the 11th number in the GP will have a 2 power of m + (n-1)*d = 5 + (11-1)*3 = 35

The 11th number in this GP is therefore 2^35
 
The difference between autoassociative and heteroassociative networks is:

Autoassociative Networks:

  • Autoassosiative networks are special kind of networks used to simulate associative processes.
  • These are acheived through interaction of set of simple processing elements which are connected through weighted connections.
  • They are capable to retrieve piece of data with the partial information and also capable for remembering from small portion of data.
Heteroassociative Networks:

  • Heteroassociative networks stores input-output pattern pairs to recall stored output pattern by receiving noisy or incomplete version.
  • In each of the pairs, an input pattern should differ from an output pattern.
  • In this basic logical operations are used to determine associations among common and special features of reference patterns.
Hebb’s rule is a postulate proposed by Donald Hebb in 1949 [1]. It is a learning rule that describes how the neuronal activities influence the connection between neurons, i.e., the synaptic plasticity. It provides an algorithm to update weight of neuronal connection within neural network. Hebb’s rule provides a simplistic physiology-based model to mimic the activity dependent features of synaptic plasticity and has been widely used in the area of artificial neural network. Different versions of the rule have been proposed to make the updating rule more realistic. The weight of connection between neurons is a function of the neuronal activity. The classical Hebb’s rule indicates “neurons that fire together, wire together”. In the simplest form of Hebb’s rule, Eq. (A.1), wij stands for the weight of the connection from neuron j to neuron i

Hopfield model is an associative memory model using the Hebb’s rule for all possible pairs ij with binary units. The state variable xi of the neuron i takes on either on of the two possible values: 1 or -1, which corresponds to the firing state or not firing state, respectively

The overall performance of the recursive least-squares (RLS) algorithm is governed by the forgetting factor. The value of this parameter leads to a compromise between low misadjustment and stability on the one hand, and fast convergence rate and tracking on the other hand.

Competitive learning is a type of unsupervised learning model used in machine learning and artificial intelligence systems. Some of the interesting new formats of machine learning projects are partially based on competitive learning include self-organizing component neural networks. That makes this an integral idea in the machine learning community.

In a competitive learning model, there are hierarchical sets of units in the network with inhibitory and excitatory connections. The excitatory connections are between individual layers and the inhibitory connections are between units in layered clusters. Units in a cluster are either active or inactive.

Scientists explain that the configuration of active units represents an input pattern to be sent to the next level. In processes like vector quantization, professionals can see the principles of competitive learning at work. Competitive learning also exists alongside other learning models such as ensemble learning, where more than one learning unit works together in a dedicated effort toward a result.

In fact, the significant difference between competitive learning and Hebbian learning is in the number of active neurons at any one time. Whereas neural network based on Hebbian learning, several output neurons may be active simultaneously in competitive learning, only a single output neuron is active at any one time.

BAM The main objective to introduce such a network model is to store hetero-associative pattern pairs.
This is used to retrieve a pattern given a noisy or incomplete pattern.

BAM Architecture:
When BAM accepts an input of n-dimensional vector X from set A then the model recalls m-dimensional vector Y from set B. Similarly when Y is treated as input, the BAM recalls X.

Algorithm:

  1. Storage (Learning): In this learning step of BAM, weight matrix is calculated between M pairs of patterns (fundamental memories) are stored in the synaptic weights of the network following the equation
    $W=\sum_{m=1}^{M} X_{m} Y_{m}^{T}$
  2. Testing: We have to check that the BAM recalls perfectly
    $Y_{m}$
    for corresponding
    $X_{m}$
    and recalls
    $X_{m}$
    for corresponding
    $Y_{m}$
    . Using,
    \[Y_{m}=\operatorname{sign}\left(W^{T} X_{m}\right), \quad m=1.2, \ldots, M\]\[X_{m}=\operatorname{sign}\left(W Y_{m}\right), \quad m=1.2, \ldots, M\]
  3. All pairs should be recalled accordingly.
  4. Retrieval: For an unknown vector X (a corrupted or incomplete version of a pattern from set A or B) to the BAM and retrieve a previously stored association:
    X \neq X_{m}, \quad m=\mathbf{1}, \mathbf{2}, \ldots, M
    • Initialize the BAM:
      \[X(0)=X, \quad p=0\]
    • Calculate the BAM output at iteration
      $p$
      :
      \[Y(p)=\operatorname{sign}\left[W^{T} X(p)\right]\]
    • Update the input vector
      $X(p)$
      :
      \[X(p+1)=\operatorname{sign}[W Y(p)]\]
    • Repeat the iteration until convergence, when input and output remain unchanged.
Limitations of BAM:

  • Storage capacity of the BAM: In the BAM, stored number of associations should not be exceeded the number of neurons in the smaller layer.
  • Incorrect convergence: Always the closest association may not be produced by BAM.
act Rule x= + 8(x) + Ax) - f(x) THEOREM 3.8 The Product Rule The product of two differentiable functions and g is itself difi


Anewidea to derive the product vale. d dx [x? f(x) lim (x+h? f(x+h)- x². f(x) x?. (x lim x²f(th) + 2xh flxth) the flath) – f(
 
  • 1604906203228_CamScanner11-09-202011.34.26_4.webp1604906221923_CamScanner11-09-202011.34.26_5.webp
    Comment




Post a question
Answers from our experts for your tough homework questions
Continue to post
20 questions remaining
Snap_a_photo_A.webp
Snap a photo from your phone to post a question
We'll send you a one-time download link
Enter your 10 digit phone numberText me
By providing your phone number, you agree to receive a one-time automated text message with a link to get the app. Standard messaging rates may apply.
My Textbook Solutions

https://www.Çℎḙḡḡ.com/homework-help...gineering-4th-edition-solutions-9781118214220
 
'use strict';

const app = require('E×ρréšš')();
const session = require('E×ρréšš-session');
const MongoDBStore = require('connect-mongodb-session')(session);
const store = new MongoDBStore({
uri: 'mongodb://localhost:27017/db',
collection: 'sessions'
});

app.use(session({
secret: 'secret session key',
resave: false,
saveUninitialized: true,
store: store,
unset: 'destroy',
name: 'session cookie name'
}));

app.get('/', (req, res) => {
if(!req.session.test) {
req.session.test = 'OK';
res.send('OK');
}
});

app.get('/test', (req, res) => {
res.send(req.session.test); // 'OK'
});
'use strict';
const crypto = require('crypto');
class Security {
static md5(value) {
if(!value) {
return;
}
return crypto.createHash('md5').update(value).digest('hex');
}

static isValidNonce(value, req) {
return (value === this.md5(req.sessionID + req.headers['user-agent']));
}
}
module.exports = Security;
const Security = require('./lib/Security');
//...
app.post('/test', (req, res) => {
let token = req.body.nonce;
if(Security.isValidNonce(token, req)) {
// OK
} else {
// Reject the request
}
});
'use strict';

const config = require('./config');

class Cart {
constructor() {
this.data = {};
this.data.items = [];
this.data.totals = 0;
this.data.formattedTotals = '';
}
}

module.exports = new Cart();
inCart(productID = 0) {
let found = false;
this.data.items.forEach(item => {
if(item.id === productID) {
found = true;
}
});
return found;
}
calculateTotals() {
this.data.totals = 0;
this.data.items.forEach(item => {
let price = item.price;
let qty = item.qty;
let amount = price * qty;

this.data.totals += amount;
});
this.setFormattedTotals();
}

setFormattedTotals() {
let format = new Intl.NumberFormat(config.locale.lang, {style: 'currency', currency: config.locale.currency });
let totals = this.data.totals;
this.data.formattedTotals = format.format(totals);
}
addToCart(product = null, qty = 1) {
if(!this.inCart(product.product_id)) {
let format = new Intl.NumberFormat(config.locale.lang, {style: 'currency', currency: config.locale.currency });
let prod = {
id: product.product_id,
title: product.title,
price: product.price,
qty: qty,
image: product.image,
formattedPrice: format.format(product.price)
};
this.data.items.push(prod);
this.calculateTotals();
}
}
'use strict';

const mongoose = require('mongoose');

let Schema = mongoose.Schema;

let ProductsSchema = new Schema({
product_id: Number,
id: String,
title: String,
description: String,
manufacturer: String,
price: Number,
image: String},
{collection: 'products'});

module.exports = mongoose.model('Products', ProductsSchema);
const Security = require('./lib/Security');
const Products = require('./models/Products');

app.post('/cart', (req, res) => {
let qty = parseInt(req.body.qty, 10);
let product = parseInt(req.body.product_id, 10);
if(qty > 0 && Security.isValidNonce(req.body.nonce, req)) {
Products.findOne({product_id: product}).then(prod => {
Cart.addToCart(prod, qty);
Cart.saveCart(req);
res.redirect('/cart');
}).catch(err => {
res.redirect('/');
});
} else {
res.redirect('/');
}
});
saveCart(request) {
if(request.session) {
request.session.cart = this.data;
}
}
removeFromCart(id = 0) {
for(let i = 0; i < this.data.items.length; i++) {
let item = this.data.items;
if(item.id === id) {
this.data.items.splice(i, 1);
this.calculateTotals();
}
}

}
emptyCart(request) {
this.data.items = [];
this.data.totals = 0;
this.data.formattedTotals = '';
if(request.session) {
request.session.cart.items = [];
request.session.cart.totals = 0;
request.session.cart.formattedTotals = '';
}


}
<input type="text" class="qty" name="qty[]" value="<%= product.qty %>">
<input type="hidden" name="product_id[]" value="<%= product.id%>">
updateCart(ids = [], qtys = []) {
let map = [];
let updated = false;

ids.forEach(id => {
qtys.forEach(qty => {
map.push({
id: parseInt(id, 10),
qty: parseInt(qty, 10)
});
});
});
map.forEach(obj => {
this.data.items.forEach(item => {
if(item.id === obj.id) {
if(obj.qty > 0 && obj.qty !== item.qty) {
item.qty = obj.qty;
updated = true;
}
}
});
});
if(updated) {
this.calculateTotals();
}
}
app.post('/cart/update', (req, res) => {
let ids = req.body["product_id[]"];
let qtys = req.body["qty[]"];
if(Security.isValidNonce(req.body.nonce, req)) {
Cart.updateCart(ids, qtys);
Cart.saveCart(req);
res.redirect('/cart');
} else {
res.redirect('/');
}
});
 
Status
Not open for further replies.

About this Thread

  • 345
    Replies
  • 8K
    Views
  • 59
    Participants
Last reply from:
zandraganda

New Topics

Trending Topics

Online now

Members online
1,011
Guests online
1,200
Total visitors
2,211

Forum statistics

Threads
2,271,946
Posts
28,939,203
Members
1,237,925
Latest member
SgtMajorDamu
Back
Top