Category: Misc

So I found out that a tesla M40 has the same amount of cuda cores as a 2080S but 2080S has tensor cores and is a lot more expensive but M40 is a lot cheaper so which would be the best bang for buck?

Price 2080S: 700$ specs: cuda cores 3072 core clock 1815MHz ram 8GB mem clock 2000 (15.5 GB effective) tensor cores: 384

Price M40: 140$(used) specs: cuda cores 3072 core clock 1110MHz ram: 12GB mem clock 1502 (6GBs effective)

Comparing price I would think for coding rendering and AI M40 would be better if you got 2 but tell me what you guys think

Hi,I am trying to run tflite model on browser. It would run client side, I have converted the model to wasm format and am able to run it successfully on browser.

Since, It would be client side, The tflite model would be accessible to everyone. Is it possible to encrypt the model in anyway, So not everyone has access to the model?

The application is built using mediapipe framework, Not sure if it would change the solution.

Thanks!

Hello there,

i often see the following code for regression problems(we have here a linear regression)

import tensorflow.compat.v1 as tf
import numpy as np
import matplotlib.pyplot as plt
learning_rate = 0.01
training_epochs = 100
x_train = np.linspace(-1, 1, 101)
y_train = 2 * x_train + np.random.randn(*x_train.shape) * 0.33
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
def model(X, w):
return tf.multiply(X, w)
w = tf.Variable(0.0, name=”weights”)
y_model = model(X, w)
cost = tf.square(Y-y_model)
train_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)
for epoch in range(training_epochs):
for (x, y) in zip(x_train, y_train):
sess.run(train_op, feed_dict={X: x, Y: y})
w_val = sess.run(w)
sess.close()
plt.scatter(x_train, y_train)
y_learned = x_train*w_val
plt.plot(x_train, y_learned, ‘r’)
plt.show()

But isnt that wrong? My problems are these lines:

for epoch in range(training_epochs):for (x, y) in zip(x_train, y_train):sess.run(train_op, feed_dict={X: x, Y: y})

Why is it a problem? Because if you look how we do it in pure mathematics it doesnt fit. We have the MSE function in math and we do gradient descent over the hole function. But here it seems that they are doing gradient descent just over the parts of MES function in line

“for (x, y) in zip(x_train, y_train):sess.run(train_op, feed_dict={X: x, Y: y})”

What do i mean with that? MSE=g1(x)+g2(x)+…+gn(x) and it seems like they do graph descent on g1(x) then on g2(x) and so on.How does TensorFlow exactly calculus in the back?
My problem is that through feed_dict={X: x, Y: y} only just one function will be called. Lets say x=1 and y=2 Tensorflow will go to X and Y then it will go to def model and only will call one part of the function of MSE lets say g1(x) but you need to go over all MSE with graph descent?

I am using Keras for boundary/contour detection using a Unet. When I use binary cross-entropy as the loss, the losses decrease over time as expected the predicted boundaries look reasonable

However, I have tried custom loss for Dice with varying LRs, none of them are working well.

smooth = 1e-6 def dice_coef(y_true, y_pred): y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) intersection = K.sum(y_true_f * y_pred_f) return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth) def dice(y_true, y_pred): return 1-dice_coef(y_true, y_pred) 

the loss values don’t improve. That is, it will show something like

loss: nan - dice: .9607 - val_loss: nan - val_dice: .9631 

I get NaNs for the losses and values for dice and val_dice that barely change as the epochs iterate. This is regardless of what I use for the LR, whether it be .01 to 1e-6

The dimensions of the train images/labels looks like N x H x W x 1, where N is the number of images, H/W are the height/width of each image

can anyone help?

Hello Guys,

I’m challenging myself to create simple 1 dimension tensor that consist of integers, range from 1-10 using the linespace function and with a shape of 6. However I haven’t been successful doing that. How do I fix this ?

My code:

[1,2,3,4,5,6,7,8,9,10]

torch.linspace(1, 1, 10)