পাইথনে সফটম্যাক্স ফাংশন কীভাবে কার্যকর করা যায়

Question

থেকে Udacity গভীর লার্নিং বর্গ , y_i এর softmax কেবল সূচকীয় পুরো ওয়াই ভেক্টরের সূচকীয় এর সমষ্টি দ্বারা বিভক্ত হল:

কোথায় S(y_i)এর softmax ফাংশন y_iএবং eসূচকীয় এবং jনেই। ইনপুট ভেক্টর ওয়াই এর কলামগুলির মধ্যে

আমি নিম্নলিখিত চেষ্টা করেছি:

import numpy as np

def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()

scores = [3.0, 1.0, 0.2]
print(softmax(scores))

যা প্রত্যাবর্তন করে:

[ 0.8360188   0.11314284  0.05083836]

তবে প্রস্তাবিত সমাধানটি হ'ল:

def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    return np.exp(x) / np.sum(np.exp(x), axis=0)

যা প্রথম বাস্তবায়ন হিসাবে একই আউটপুট উত্পাদন করে , যদিও প্রথম বাস্তবায়ন স্পষ্টভাবে প্রতিটি কলাম এবং সর্বাধিকের পার্থক্য নেয় এবং তার পরে যোগফলকে ভাগ করে।

কেউ গাণিতিকভাবে দেখাতে পারেন কেন? একটি সঠিক এবং অন্যটি ভুল?

কোড এবং সময় জটিলতার ক্ষেত্রে বাস্তবায়ন কি একই রকম? কোনটি আরও দক্ষ?

Comments

আমি আগ্রহী যে আপনি সর্বাধিক ফাংশন দিয়ে এভাবে কেন প্রয়োগ করার চেষ্টা করেছিলেন। আপনাকে কীভাবে সেভাবে ভাবতে বাধ্য করেছে?

— বিবিছফ

আমি জানি না, আমি সর্বাধিক 0 হিসাবে গণ্য করার চিন্তা করেছি এবং গ্রাফটি বাম দিকে সরানো এবং 0-তে ক্লিপ করা সাহায্য করে। তারপর আমার পরিসীমা সাজানোর থেকে কমান -inf to +infকরতে -inf to 0। আমার ধারণা আমি ওভারটিকিং করছি was hahahaaa

— আলভাস

আমার এখনও একটি সাব আছে) নীচের উত্তর বলে মনে হচ্ছে না। axis = 0উদাসতা দ্বারা প্রস্তাবিত উত্তরের তাত্পর্যটি কী ?

— পারভা ঠাকর

আপনি যদি ন্যালি ডকুমেন্টেশনটি একবার দেখে থাকেন তবে তা (x, অক্ষ = 0) - এবং একইভাবে অক্ষ = 1-- কী করে তা আলোচনা করে। সংক্ষেপে, এটি দিকনির্দেশ সরবরাহ করে যাতে অ্যারের অ্যারের যোগফল। এই ক্ষেত্রে, এটি ভেক্টরগুলির সাথে বরাবর যোগ করতে বলে। এই ক্ষেত্রে, এটি সফটম্যাক্স ফাংশনে ডিনোনিটারগুলির সাথে সম্পর্কিত।

— বিবিচফ

এটি প্রতি অন্যান্য সপ্তাহের মতো, আমার গণিতটি সঠিক না হওয়ায় এ পর্যন্ত এটির সঠিক উত্তর রয়েছে)) কোনও উত্তর নেই এমন কোন গণিত যা সঠিক উত্তর দিতে পারে না?

— আলভাস

Answer 1

এগুলি উভয়ই সঠিক, তবে সংখ্যার স্থায়িত্বের দৃষ্টিকোণ থেকে আপনার পছন্দ হয়।

আপনি দিয়ে শুরু

e ^ (x - max(x)) / sum(e^(x - max(x))

আমাদের যে a b (b - c) = (a ^ b) / (a ​​^ c) ব্যবহার করে

= e ^ x / (e ^ max(x) * sum(e ^ x / e ^ max(x)))

= e ^ x / sum(e ^ x)

যা অন্য উত্তর বলে। আপনি কোনও ভেরিয়েবলের সাথে সর্বাধিক (এক্স) প্রতিস্থাপন করতে পারেন এবং এটি বাতিল হয়ে যাবে।

Comments

আরও স্পষ্টতার জন্য আপনার উত্তর @ ট্রেভারএম-কে পুনরায় ফর্ম্যাট করা: ই ^ (বি - সি) = (একটি ^ বি) / (একটি using) ব্যবহার করে ই ^ (এক্স - ম্যাক্স (এক্স)) / যোগ (ই ^ (এক্স - ম্যাক্স (এক্স)) গ) আমাদের রয়েছে, = ই ^ এক্স / {ই ^ সর্বোচ্চ (এক্স) * যোগফল (ই ^ এক্স / ই ^ সর্বাধিক (এক্স))} = ই sum এক্স /

— সম

@ ট্রেভর মেরিফিল্ড, আমি মনে করি না যে প্রথম পদ্ধতির কোনও "অপ্রয়োজনীয় পদ" পেয়েছিল। আসলে এটি দ্বিতীয় পদ্ধতির চেয়ে ভাল। আমি এই বিষয়টি একটি পৃথক উত্তর হিসাবে যুক্ত করেছি।

— শাগুন সোধানী

@ শাগুন আপনি সঠিক আছেন দুটি গাণিতিকভাবে সমতুল্য তবে আমি সংখ্যার স্থায়িত্ব বিবেচনা করি নি।

— ট্রেভর মেরিফিল্ড

আশা করি আপনার আপত্তি নেই: লোকেরা মন্তব্য না পড়লে (বা মন্তব্যগুলি অদৃশ্য হয়ে যায়) আমি "অপ্রয়োজনীয় শব্দ" সম্পাদনা করেছি। এই পৃষ্ঠাটি অনুসন্ধান-ইঞ্জিনগুলি থেকে বেশ কিছুটা ট্র্যাফিক পেয়েছে এবং এটি বর্তমানে লোকেরা দেখছে যে এটি প্রথম উত্তর।

— অ্যালেক্স রিলি

আমি অবাক হয়েছি কেন আপনি সর্বাধিক (এক্স) এবং সর্বোচ্চ (অ্যাবস (এক্স)) বিয়োগ করবেন না (মান নির্ধারণের পরে সাইনটি ঠিক করুন)। আপনার সমস্ত মান যদি শূন্যের নীচে হয় এবং তাদের নিখুঁত মানের মধ্যে খুব বড় হয় এবং কেবলমাত্র মান (সর্বোচ্চ) শূন্যের কাছাকাছি থাকে, সর্বাধিক বিয়োগ করলে কোনও পরিবর্তন হবে না। এটি কি এখনও সংখ্যাগতভাবে অস্থির হবে না?

— Cerno

Answer 2

(ভাল ... এখানে প্রশ্ন এবং উত্তর উভয়ই অনেক বিভ্রান্তি ...)

প্রথমত, দুটি সমাধান (যেমন আপনার এবং প্রস্তাবিত একটি) সমতুল্য নয় ; তারা ঘটতে মাত্র 1-ডি স্কোর অ্যারে বিশেষ মামলায় সমতুল্য যাবে। আপনি যদি উদাসিতা কুইজে প্রদত্ত উদাহরণটিতে 2-ডি স্কোর অ্যারের চেষ্টা করে থাকেন তবে আপনি এটি আবিষ্কার করতে পারতেন।

ফলাফল অনুসারে, দুটি সমাধানের মধ্যে একমাত্র আসল পার্থক্য হ'ল axis=0যুক্তি। এটি কেস তা দেখতে, আসুন আপনার সমাধানটি চেষ্টা করুন ( your_softmax) এবং এমন এক যেখানে পার্থক্য কেবল axisযুক্তি:

import numpy as np

# your solution:
def your_softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()

# correct solution:
def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0) # only difference

আমি যেমন বলেছি, 1-ডি স্কোর অ্যারের জন্য, ফলাফলগুলি সত্যই অভিন্ন:

scores = [3.0, 1.0, 0.2]
print(your_softmax(scores))
# [ 0.8360188   0.11314284  0.05083836]
print(softmax(scores))
# [ 0.8360188   0.11314284  0.05083836]
your_softmax(scores) == softmax(scores)
# array([ True,  True,  True], dtype=bool)

তবুও, পরীক্ষার উদাহরণ হিসাবে উদাসিটি কুইজে দেওয়া 2-ডি স্কোর অ্যারের ফলাফল এখানে রয়েছে:

scores2D = np.array([[1, 2, 3, 6],
                     [2, 4, 5, 6],
                     [3, 8, 7, 6]])

print(your_softmax(scores2D))
# [[  4.89907947e-04   1.33170787e-03   3.61995731e-03   7.27087861e-02]
#  [  1.33170787e-03   9.84006416e-03   2.67480676e-02   7.27087861e-02]
#  [  3.61995731e-03   5.37249300e-01   1.97642972e-01   7.27087861e-02]]

print(softmax(scores2D))
# [[ 0.09003057  0.00242826  0.01587624  0.33333333]
#  [ 0.24472847  0.01794253  0.11731043  0.33333333]
#  [ 0.66524096  0.97962921  0.86681333  0.33333333]]

ফলাফলগুলি পৃথক - দ্বিতীয়টি উদাসিটি কুইজে প্রত্যাশিত সাথে সত্যই অভিন্ন, যেখানে সত্যই সমস্ত কলাম 1 এর সমষ্টি, যা প্রথম (ভুল) ফলাফলের ক্ষেত্রে হয় না।

সুতরাং, সমস্ত গোলমাল আসলে বাস্তবায়নের বিশদ ছিল - axisযুক্তি। মতে numpy.sum ডকুমেন্টেশন :

ডিফল্ট, অক্ষ = কিছুই নয়, ইনপুট অ্যারের সমস্ত উপাদানের যোগফল দেবে

এখানে থাকাকালীন আমরা সারি অনুসারে সমষ্টি করতে চাই axis=0। 1-ডি অ্যারের জন্য, (কেবল) সারিটির যোগফল এবং সমস্ত উপাদানগুলির যোগফল অভিন্ন হতে পারে, সুতরাং সেই ক্ষেত্রে আপনার অভিন্ন ফলাফল ...

দ্য axisইস্যু সরাইয়া, আপনার বাস্তবায়ন (অর্থাত আপনার সর্বোচ্চ প্রথম বিয়োগ করতে পছন্দ) আসলে ভাল প্রস্তাব সমাধান চেয়ে! প্রকৃতপক্ষে, এটি সফটম্যাক্স ফাংশনটি বাস্তবায়নের প্রস্তাবিত উপায় - ন্যায্যতার জন্য এখানে দেখুন (সংখ্যার স্থায়িত্ব, এখানে আরও কয়েকটি উত্তর দ্বারা নির্দেশিতও)।

Comments

ঠিক আছে, আপনি যদি কেবল বহুমাত্রিক অ্যারে সম্পর্কে কথা বলছেন। প্রথম সমাধানটি সহজেই axisউভয় maxএবং এর সাথে যুক্তি যুক্ত করে ঠিক করা যায় sum। যাইহোক, প্রথম বাস্তবায়নটি এখনও আরও ভাল, যেহেতু আপনি গ্রহণ করার সময় সহজেই উপচে পড়তে পারেনexp

— লুই ইয়াং

@ লুইসইং আমি অনুসরণ করছি না; "প্রথম" সমাধানটি কোনটি? কোনটি ব্যবহার করে নাexp ? axisযুক্তি যুক্ত করা ছাড়া এখানে আর কি সংশোধন করা হয়েছে ?

— মরুভূমি

প্রথম সমাধানটি @ আলবাস থেকে সমাধানটি বোঝায়। পার্থক্যটি হ'ল আলভাসের প্রশ্নের প্রস্তাবিত সমাধানটি সর্বাধিক বিয়োগের অংশটি অনুপস্থিত। এটি সহজেই ওভারফ্লো হতে পারে উদাহরণস্বরূপ, এক্সপ (1000) / (এক্সপ্রেস (1000) + এক্সপ্রেস (1001)) বনাম এক্সপ (-1) / (এক্সপ্রেস (-1) + এক্সপ্রেস (0)) গণিতে সমান তবে প্রথমটি উপচে পড়বে।

— লুই ইয়াং

@ লুইস ইয়াং এখনও, নিশ্চিত নয় যে আমি আপনার মন্তব্যের প্রয়োজনীয়তা বুঝতে পেরেছি - উত্তরে এগুলি ইতিমধ্যে সুস্পষ্টভাবে সম্বোধন করা হয়েছে।

— মরুভূমি

@ লুইস ইয়াং দয়া করে থ্রেডের (পরবর্তী) জনপ্রিয়তা আপনাকে বোকা বানাবেন না এবং যে উত্তরটি নিজের উত্তরটি দেওয়া হয়েছিল তা অনুধাবন করার চেষ্টা করবেন না: বিস্মিত ওপি (" উভয়ই একই ফলাফল দেয় "), এবং একটি (এখনও!) স্বীকৃত উত্তর দাবি করেছেন যে " উভয়ই সঠিক " (ভাল, তারা নেই )। উত্তরটি কখনই বোঝানো হয়নি " এটি সাধারণভাবে সফটম্যাক্স গণনা করার সবচেয়ে সঠিক এবং দক্ষ উপায় "; এটি কেবলমাত্র ন্যায়সঙ্গত করা মানে কেন , নির্দিষ্ট উদাসীনতা কুইজে আলোচিত, 2 টি সমাধান সমতুল্য নয় ।

— মরুভূমি

Answer 3

সুতরাং, এটি সত্যিই মরুভূমির উত্তরের একটি মন্তব্য তবে আমি আমার খ্যাতির কারণে এটি নিয়ে এখনও মন্তব্য করতে পারি না। যেমনটি তিনি উল্লেখ করেছেন, আপনার ইনপুটটি কেবলমাত্র সঠিক যদি আপনার ইনপুটটিতে কোনও একক নমুনা থাকে। যদি আপনার ইনপুটটিতে বেশ কয়েকটি নমুনা থাকে তবে এটি ভুল। তবে মরুভূমির সমাধানও ভুল wrong সমস্যাটি হ'ল একবার তিনি 1-মাত্রিক ইনপুট নেন এবং তারপরে তিনি 2-মাত্রিক ইনপুট নেন। আমি আপনাকে এটি দেখাতে দিন।

import numpy as np

# your solution:
def your_softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()

# desertnaut solution (copied from his answer): 
def desertnaut_softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0) # only difference

# my (correct) solution:
def softmax(z):
    assert len(z.shape) == 2
    s = np.max(z, axis=1)
    s = s[:, np.newaxis] # necessary step to do broadcasting
    e_x = np.exp(z - s)
    div = np.sum(e_x, axis=1)
    div = div[:, np.newaxis] # dito
    return e_x / div

মরুভূমির উদাহরণ নিতে দাও:

x1 = np.array([[1, 2, 3, 6]]) # notice that we put the data into 2 dimensions(!)

এটি আউটপুট:

your_softmax(x1)
array([[ 0.00626879,  0.01704033,  0.04632042,  0.93037047]])

desertnaut_softmax(x1)
array([[ 1.,  1.,  1.,  1.]])

softmax(x1)
array([[ 0.00626879,  0.01704033,  0.04632042,  0.93037047]])

আপনি দেখতে পাচ্ছেন যে এই পরিস্থিতিতে মরুভূমি সংস্করণ ব্যর্থ হবে। (ইনপুটটি এনপি.আর্রে ([1, 2, 3, 6]) এর মতো মাত্র এক মাত্রিক হলে তা হবে না।

আমরা 2 মাত্রিক ইনপুট কেন ব্যবহার করি তার কারণেই এখন 3 টি নমুনা ব্যবহার করা যাক। নিম্নলিখিত x2 মরুভূমি উদাহরণ থেকে এক হিসাবে একই নয়।

x2 = np.array([[1, 2, 3, 6],  # sample 1
               [2, 4, 5, 6],  # sample 2
               [1, 2, 3, 6]]) # sample 1 again(!)

এই ইনপুটটিতে 3 টি নমুনা সহ একটি ব্যাচ রয়েছে। তবে নমুনা এক এবং তিনটি মূলত একই। আমরা এখন 3 সারি সফটম্যাক্স অ্যাক্টিভেশনগুলি আশা করি যেখানে প্রথমটি তৃতীয় এবং আমাদের এক্স 1 এর অ্যাক্টিভেশন হিসাবে একই হওয়া উচিত!

your_softmax(x2)
array([[ 0.00183535,  0.00498899,  0.01356148,  0.27238963],
       [ 0.00498899,  0.03686393,  0.10020655,  0.27238963],
       [ 0.00183535,  0.00498899,  0.01356148,  0.27238963]])


desertnaut_softmax(x2)
array([[ 0.21194156,  0.10650698,  0.10650698,  0.33333333],
       [ 0.57611688,  0.78698604,  0.78698604,  0.33333333],
       [ 0.21194156,  0.10650698,  0.10650698,  0.33333333]])

softmax(x2)
array([[ 0.00626879,  0.01704033,  0.04632042,  0.93037047],
       [ 0.01203764,  0.08894682,  0.24178252,  0.65723302],
       [ 0.00626879,  0.01704033,  0.04632042,  0.93037047]])

আমি আশা করি আপনি দেখতে পাচ্ছেন যে এটি কেবলমাত্র আমার সমাধানের ক্ষেত্রে।

softmax(x1) == softmax(x2)[0]
array([[ True,  True,  True,  True]], dtype=bool)

softmax(x1) == softmax(x2)[2]
array([[ True,  True,  True,  True]], dtype=bool)

অতিরিক্তভাবে, এখানে টেনসরফ্লোস সফটম্যাক্স বাস্তবায়নের ফলাফল রয়েছে:

import tensorflow as tf
import numpy as np
batch = np.asarray([[1,2,3,6],[2,4,5,6],[1,2,3,6]])
x = tf.placeholder(tf.float32, shape=[None, 4])
y = tf.nn.softmax(x)
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(y, feed_dict={x: batch})

এবং ফলাফল:

array([[ 0.00626879,  0.01704033,  0.04632042,  0.93037045],
       [ 0.01203764,  0.08894681,  0.24178252,  0.657233  ],
       [ 0.00626879,  0.01704033,  0.04632042,  0.93037045]], dtype=float32)

Comments

এটি একটি মন্তব্যের এক নরক হত ;-)

— মাইকেল বেঞ্জামিন

np.exp (z) / np.sum (np.exp (z), অক্ষ = 1, কিপডিমস = ট্রু) আপনার সফটম্যাক্স ফাংশন হিসাবে একই ফলাফলে পৌঁছায়। এর সাথে পদক্ষেপগুলি অপ্রয়োজনীয়।

— পাবটোরে

এর জায়গায় s = s[:, np.newaxis], s = s.reshape(z.shape[0],1)এছাড়াও কাজ করা উচিত।

— দেবাশীষ

এই পৃষ্ঠায় অনেক ভুল / অদক্ষ সমাধান। নিজেরাই অনুগ্রহ করুন এবং পাবটোরের ব্যবহার করুন

— মিস পামার

@ পাবটোরের অর্থ কী অক্ষ = -1? অক্ষ = 1 একক মাত্রিক ইনপুট জন্য কাজ করবে না

— ডায়ার্ড দ্য ট্রাইহার্ড

Answer 4

আমি বলব যে উভয়ই গাণিতিকভাবে সঠিক, প্রয়োগ-ভিত্তিক, প্রথমটি আরও ভাল। সফটম্যাক্স গণনা করার সময়, মধ্যবর্তী মানগুলি খুব বড় হয়ে উঠতে পারে। দুটি বৃহত সংখ্যার বিভাজন সংখ্যাগতভাবে অস্থির হতে পারে। এই নোটগুলি (স্ট্যানফোর্ড থেকে) একটি সাধারণীকরণ কৌশল সম্পর্কে উল্লেখ করে যা মূলত আপনি যা করছেন you

Comments

বিপর্যয়কর বাতিলকরণের প্রভাবগুলি হ্রাস করা যায় না।

— সিজার

Answer 5

স্কলারন সফটম্যাক্স প্রয়োগের প্রস্তাব দেয়

from sklearn.utils.extmath import softmax
import numpy as np

x = np.array([[ 0.50839931,  0.49767588,  0.51260159]])
softmax(x)

# output
array([[ 0.3340521 ,  0.33048906,  0.33545884]]) 

Comments

এটি ঠিক কীভাবে নির্দিষ্ট প্রশ্নের উত্তর দেয়, যা নিজেই বাস্তবায়ন সম্পর্কে এবং কোনও তৃতীয় পক্ষের লাইব্রেরিতে প্রাপ্যতা সম্পর্কে নয়?

— মরুভূমি

আমি উভয় পদ্ধতির ফলাফল যাচাই করতে তৃতীয় পক্ষের প্রয়োগের সন্ধান করছিলাম। এই মন্তব্যটি এইভাবে সহায়তা করে।

— ইউজিনিও এফ মার্টিনেজ পাচেকো

Answer 6

গাণিতিক দিক থেকে উভয় পক্ষই সমান।

এবং আপনি সহজেই এটি প্রমাণ করতে পারেন। আসুন m=max(x)। এখন আপনার ফাংশনটি softmaxকোনও ভেক্টরকে ফিরিয়ে দেয়, যার আই-তম স্থানাঙ্ক সমান

লক্ষ্য করুন যে এটি যে কোনওর জন্য কাজ করে m, কারণ সমস্ত (এমনকি জটিল) সংখ্যার জন্যe^m != 0

• গণনাগত জটিলতার দৃষ্টিকোণ থেকে এগুলিও সমতুল্য এবং উভয়ই O(n)সময়মতো চালায় , যেখানে nকোনও ভেক্টরের আকার।

• সংখ্যার স্থায়িত্বের দৃষ্টিকোণ থেকে , প্রথম সমাধানটি অগ্রাধিকার দেওয়া হয়, কারণ e^xখুব দ্রুত বৃদ্ধি পায় এবং এমনকি xএটির বেশিরভাগ ছোট মানগুলির জন্যও উপচে পড়বে। সর্বাধিক মান বিয়োগ করা এই ওভারফ্লো থেকে মুক্তি পেতে দেয়। আমি যে জিনিসটির কথা বলছিলাম তা ব্যবহারিকভাবে অভিজ্ঞতা পেতে x = np.array([1000, 5])আপনার উভয় ফাংশনকেই ফিড দেওয়ার চেষ্টা করুন । একটি সঠিক সম্ভাবনা ফিরিয়ে দেবে, দ্বিতীয়টি প্রবাহিত হবেnan

• আপনার সমাধানটি কেবল ভেক্টরদের জন্যই কাজ করে (উদাসিটি কুইজ আপনি এটি ম্যাট্রিকের জন্যও গণনা করতে চান)। এটি ঠিক করার জন্য আপনার ব্যবহার করা দরকারsum(axis=0)

Comments

যখন ভ্যাক্টরের পরিবর্তে ম্যাট্রিক্সে সফটম্যাক্স গণনা করতে সক্ষম হবেন? অর্থাত্ মডেল কি ম্যাট্রিক্স আউটপুট? এটি আরও মাত্রিক হতে পারে?

— mrgloom

"সংখ্যার স্থায়িত্বের দৃষ্টিকোণ থেকে, দ্বিতীয় সমাধানটি অগ্রাধিকার দেওয়া হয়েছে ..." এর মধ্যে প্রথম সমাধানটি কী বোঝায় ?

— ডেটাম্যান

Answer 7

সম্পাদনা । সংস্করণ 1.2.0 হিসাবে, স্কিপিটিতে একটি বিশেষ কার্যকারিতা হিসাবে সফটম্যাক্স অন্তর্ভুক্ত রয়েছে:

https://scipy.github.io/devdocs/generated/scipy.special.softmax.html

আমি কোনও অক্ষের উপরে সফটম্যাক্স প্রয়োগ করে একটি ফাংশন লিখেছিলাম:

def softmax(X, theta = 1.0, axis = None):
    """
    Compute the softmax of each element along an axis of X.

    Parameters
    ----------
    X: ND-Array. Probably should be floats. 
    theta (optional): float parameter, used as a multiplier
        prior to exponentiation. Default = 1.0
    axis (optional): axis to compute values along. Default is the 
        first non-singleton axis.

    Returns an array the same size as X. The result will sum to 1
    along the specified axis.
    """

    # make X at least 2d
    y = np.atleast_2d(X)

    # find axis
    if axis is None:
        axis = next(j[0] for j in enumerate(y.shape) if j[1] > 1)

    # multiply y against the theta parameter, 
    y = y * float(theta)

    # subtract the max for numerical stability
    y = y - np.expand_dims(np.max(y, axis = axis), axis)

    # exponentiate y
    y = np.exp(y)

    # take the sum along the specified axis
    ax_sum = np.expand_dims(np.sum(y, axis = axis), axis)

    # finally: divide elementwise
    p = y / ax_sum

    # flatten if X was 1D
    if len(X.shape) == 1: p = p.flatten()

    return p

অন্যান্য ব্যবহারকারীদের বর্ণিত হিসাবে সর্বোচ্চটি বিয়োগ করা ভাল অনুশীলন। আমি এটি সম্পর্কে এখানে একটি বিস্তারিত পোস্ট লিখেছি ।

Answer 8

তারা কেন ব্যবহার করেছে তা এখানে জানতে পারবেন - max।

সেখান থেকে:

"আপনি যখন অনুশীলনে সফটম্যাক্স ফাংশনটি গণনা করার জন্য কোড লিখছেন, তখন মধ্যবর্তী পদগুলি এক্সফেনশিয়ালের কারণে খুব বড় হতে পারে large

Answer 9

আরও সংক্ষিপ্ত সংস্করণটি হ'ল:

def softmax(x):
    return np.exp(x) / np.exp(x).sum(axis=0)

Comments

এটি পাটিগণিত ওভারফ্লোতে চলে যেতে পারে

— minhle_r7

Answer 10

বিকল্প সমাধান দেওয়ার জন্য, আপনার আর্গুমেন্টগুলি যে আকারে exp(x)প্রবাহিত হবে (নেতিবাচক ক্ষেত্রে) বা ওভারফ্লো হবে (ইতিবাচক ক্ষেত্রে) সেই পরিমাণ বিবেচনা করুন । এখানে আপনি যতক্ষণ সম্ভব লগ স্পেসে থাকতে চান, কেবলমাত্র শেষে যেখানে আপনি বিশ্বাস করতে পারেন ফলাফলটি ভাল আচরণ করা হবে।

import scipy.special as sc
import numpy as np

def softmax(x: np.ndarray) -> np.ndarray:
    return np.exp(x - sc.logsumexp(x))

Comments

এটি পোস্টার কোডের সমান করতে, আপনাকে axis=0যুক্তি হিসাবে যুক্ত করতে হবে logsumexp।

— বিজন লিন্ডকভিস্ট

বিকল্পভাবে, লগসিউমপেক্সে পাস করার জন্য কেউ অতিরিক্ত আরগগুলি প্যাক করতে পারে।

— পিক্যালাক্সাল্ট

Answer 11

আমার টেনসরফ্লো থেকে ঘন স্তর আউটপুট সঙ্গে সামঞ্জস্যপূর্ণ কিছু প্রয়োজন ।

@ ডেজার্টনট থেকে সমাধানটি এই ক্ষেত্রে কার্যকর হয় না কারণ আমার কাছে ব্যাচের ডেটা রয়েছে। অতএব, আমি আরও একটি সমাধান নিয়ে এসেছি যা উভয় ক্ষেত্রেই কাজ করা উচিত:

def softmax(x, axis=-1):
    e_x = np.exp(x - np.max(x)) # same code
    return e_x / e_x.sum(axis=axis, keepdims=True)

ফলাফল:

logits = np.asarray([
    [-0.0052024,  -0.00770216,  0.01360943, -0.008921], # 1
    [-0.0052024,  -0.00770216,  0.01360943, -0.008921]  # 2
])

print(softmax(logits))

#[[0.2492037  0.24858153 0.25393605 0.24827873]
# [0.2492037  0.24858153 0.25393605 0.24827873]]

রেফ: টেনসরফ্লো সফটম্যাক্স

Comments

কেবল মনে রাখবেন যে উত্তরটি প্রশ্নের মধ্যে বর্ণিত একটি খুব নির্দিষ্ট সেটিংসকে বোঝায় ; এটি কখনই 'কোনও পরিস্থিতিতে সাধারণভাবে সফটম্যাক্সের গণনা করা বা আপনার পছন্দসই ডেটা ফর্ম্যাটে' বোঝানো হয়নি ...

— মরুভূমি

আমি দেখছি, আমি এটি এখানে রেখেছি কারণ প্রশ্নটি "উদাসিতার গভীর শিক্ষার শ্রেণি" বোঝায় এবং আপনি যদি মডেলটি তৈরি করতে টেনসরফ্লো ব্যবহার করছেন তবে এটি কাজ করবে না। আপনার সমাধানটি দুর্দান্ত এবং পরিষ্কার তবে এটি কেবল খুব নির্দিষ্ট দৃশ্যে কাজ করে। যাই হোক ধন্যবাদ.

— লুকাস ক্যাসাগ্রান্ডে

Answer 12

আমি এটি প্রস্তাব করব:

def softmax(z):
    z_norm=np.exp(z-np.max(z,axis=0,keepdims=True))
    return(np.divide(z_norm,np.sum(z_norm,axis=0,keepdims=True)))

এটি স্টচাস্টিকের পাশাপাশি ব্যাচের পক্ষেও কাজ করবে।
আরও বিশদের জন্য দেখুন: https://medium.com/@ravish1729/analysis-of-softmax-function-ad058d6a564d

Answer 13

সংখ্যাগত স্থায়িত্ব বজায় রাখার জন্য, সর্বোচ্চ (এক্স) বিয়োগ করা উচিত। নীচে সফটম্যাক্স ফাংশনের কোড রয়েছে;

ডিফ সফটম্যাক্স (এক্স):

if len(x.shape) > 1:
    tmp = np.max(x, axis = 1)
    x -= tmp.reshape((x.shape[0], 1))
    x = np.exp(x)
    tmp = np.sum(x, axis = 1)
    x /= tmp.reshape((x.shape[0], 1))
else:
    tmp = np.max(x)
    x -= tmp
    x = np.exp(x)
    tmp = np.sum(x)
    x /= tmp


return x

Answer 14

ইতিমধ্যে উপরের উত্তরে অনেক বিস্তারিতভাবে উত্তর দেওয়া হয়েছে। maxঅতিরিক্ত প্রবাহ এড়াতে বিয়োগ করা হয়। আমি এখানে পাইথন 3 এ আরও একটি বাস্তবায়ন যুক্ত করছি।

import numpy as np
def softmax(x):
    mx = np.amax(x,axis=1,keepdims = True)
    x_exp = np.exp(x - mx)
    x_sum = np.sum(x_exp, axis = 1, keepdims = True)
    res = x_exp / x_sum
    return res

x = np.array([[3,2,4],[4,5,6]])
print(softmax(x))

Answer 15

প্রত্যেকে তাদের সমাধান পোস্ট করে বলে মনে হচ্ছে তাই আমি আমার পোস্ট করব:

def softmax(x):
    e_x = np.exp(x.T - np.max(x, axis = -1))
    return (e_x / e_x.sum(axis=0)).T

আমি স্কলারন থেকে আমদানি করা ঠিক একই ফলাফল পেতে:

from sklearn.utils.extmath import softmax

Answer 16

import tensorflow as tf
import numpy as np

def softmax(x):
    return (np.exp(x).T / np.exp(x).sum(axis=-1)).T

logits = np.array([[1, 2, 3], [3, 10, 1], [1, 2, 5], [4, 6.5, 1.2], [3, 6, 1]])

sess = tf.Session()
print(softmax(logits))
print(sess.run(tf.nn.softmax(logits)))
sess.close()

Comments

এসও আপনাকে স্বাগতম। আপনার কোড প্রশ্নের উত্তর কীভাবে দেয় তার একটি ব্যাখ্যা সর্বদা সহায়ক।

— নিক

Answer 17

সমস্ত প্রতিক্রিয়া এবং CS231n নোটের ভিত্তিতে , আমাকে সংক্ষিপ্ত করার অনুমতি দিন:

def softmax(x, axis):
    x -= np.max(x, axis=axis, keepdims=True)
    return np.exp(x) / np.exp(x).sum(axis=axis, keepdims=True)

ব্যবহার:

x = np.array([[1, 0, 2,-1],
              [2, 4, 6, 8], 
              [3, 2, 1, 0]])
softmax(x, axis=1).round(2)

আউটপুট:

array([[0.24, 0.09, 0.64, 0.03],
       [0.  , 0.02, 0.12, 0.86],
       [0.64, 0.24, 0.09, 0.03]])

Answer 18

আমি সমস্যার আরও কিছুটা বোঝার জন্য পরিপূরক চাই। এখানে অ্যারের সর্বাধিক বিয়োগ করা সঠিক। তবে আপনি যদি অন্য পোস্টে কোডটি চালান, আপনি দেখতে পাবেন যে অ্যারে 2 ডি বা উচ্চতর মাত্রার হলে এটি আপনাকে সঠিক উত্তর দিচ্ছে না।

এখানে আমি আপনাকে কিছু পরামর্শ দিচ্ছি:

1. সর্বোচ্চ পেতে এক্স-অক্ষের সাথে এটি করার চেষ্টা করুন, আপনি একটি 1 ডি অ্যারে পাবেন।
2. আপনার সর্বোচ্চ অ্যারেটিকে মূল আকারে পুনরায় আকার দিন।
3. এক্সপেনশিয়াল মান পেতে এনপি.এক্সপি করুন।
4. অক্ষ বরাবর এনপি.সুম করুন।
5. চূড়ান্ত ফলাফল পান।

ফলাফল অনুসরণ করুন আপনি ভেক্টরাইজেশন করে সঠিক উত্তর পাবেন। যেহেতু এটি কলেজের হোম ওয়ার্কের সাথে সম্পর্কিত, আমি এখানে সঠিক কোডটি পোস্ট করতে পারি না, তবে আপনি যদি বুঝতে না পারেন তবে আমি আরও পরামর্শ দিতে চাই।

Comments

এটি কোনও কলেজের হোম ওয়ার্কের সাথে সম্পর্কিত নয়, কেবল একটি অ-অনুমোদনপ্রাপ্ত কোর্সে একটি অ-অগ্রেডেড অনুশীলন কুইজের সাথে সম্পর্কিত, যেখানে পরবর্তী

— উত্তরটিতে

Answer 19

সফটম্যাক্স ফাংশনের উদ্দেশ্য ভেক্টরগুলির অনুপাত সংরক্ষণ করা যেমন সিগময়েডের সাথে শেষ পয়েন্টগুলি স্কুয়েশ করার মানগুলির সাথে পরিপূর্ণ (যেমন +/- 1 (তানহ) বা 0 থেকে 1 (লজিস্টিকাল)) হিসাবে থাকে। এর কারণ এটি শেষ-পয়েন্টগুলিতে পরিবর্তনের হার সম্পর্কে আরও তথ্য সংরক্ষণ করে এবং এভাবে 1-অফ-এন আউটপুট এনকোডিং সহ নিউরাল নেটগুলির ক্ষেত্রে আরও প্রযোজ্য (যেমন আমরা যদি শেষ পয়েন্টগুলি স্কোয়াশ করি তবে এটি 1 টির পার্থক্য করা আরও শক্ত হবে) -অন-এন আউটপুট ক্লাস কারণ আমরা বলতে পারি না যে কোনটি "বৃহত্তম" বা "ক্ষুদ্রতম" কারণ তারা স্কুইশ হয়েছে)); এছাড়াও এটি মোট আউটপুট যোগফলকে 1 করে তোলে এবং স্পষ্ট বিজয়ী 1 এর কাছাকাছি হবে তবে অন্য সংখ্যাগুলি একে অপরের সাথে সমান হবে 1 / পি, যেখানে পি একই মানের সাথে আউটপুট নিউরনের সংখ্যা।

ভেক্টর থেকে সর্বাধিক মান বিয়োগ করার উদ্দেশ্যটি হ'ল আপনি যখন ই-এক্স এক্সপেনারগুলি করেন তখন আপনি খুব উচ্চ মূল্য পেতে পারেন যা টাইয়ের দিকে সরে যাওয়া সর্বাধিক মানটিতে ভাসমান ক্লিপগুলি ক্লিপ করে যা এই উদাহরণের ক্ষেত্রে এটি নয়। এটি একটি বড় সমস্যা হয়ে দাঁড়ায় যদি আপনি aণাত্মক সংখ্যা তৈরির জন্য সর্বাধিক মানটি বিয়োগ করেন তবে আপনার একটি নেতিবাচক এক্সপেনশন রয়েছে যা অনুপাত পরিবর্তনকারী মানগুলিকে দ্রুত সঙ্কুচিত করে, যা পোস্টারের প্রশ্নে ঘটেছিল এবং ভুল উত্তর পেয়েছে।

উদাসিতা দ্বারা সরবরাহ করা উত্তর হ'ল HORRIBLY অক্ষম। আমাদের প্রথমে যা করতে হবে তা হ'ল সমস্ত ভেক্টর উপাদানগুলির জন্য e ^ y_j গণনা করা, এই ভ্যালুগুলি রাখুন, তারপরে তাদের যোগফল এবং ভাগ করুন। উদাসিটি যেখানে বিশৃঙ্খলা হয়েছে সেখানে তারা e ^ y_j দুই গুণ হিসাব করে !!! এখানে সঠিক উত্তর:

def softmax(y):
    e_to_the_y_j = np.exp(y)
    return e_to_the_y_j / np.sum(e_to_the_y_j, axis=0)

Answer 20

লক্ষ্যটি ছিল নম্পি এবং টেনসরফ্লো ব্যবহার করে অনুরূপ ফলাফল অর্জন করা। আসল উত্তর থেকে একমাত্র পরিবর্তন হ'ল এপিআই-এর axisপ্যারামিটার np.sum।

প্রাথমিক পদ্ধতির : axis=0- মাত্রা N হয় যখন এটি উদ্দেশ্যপ্রণোদিত ফলাফল সরবরাহ করে না This

পরিবর্তিত পদ্ধতির : axis=len(e_x.shape)-1- সর্বদা শেষ মাত্রায় যোগফল। এটি টেনসরফ্লো এর সফটম্যাক্স ফাংশন হিসাবে অনুরূপ ফলাফল সরবরাহ করে।

def softmax_fn(input_array):
    """
    | **@author**: Prathyush SP
    |
    | Calculate Softmax for a given array
    :param input_array: Input Array
    :return: Softmax Score
    """
    e_x = np.exp(input_array - np.max(input_array))
    return e_x / e_x.sum(axis=len(e_x.shape)-1)

Answer 21

টেনস্রফ্লো আনস স্কিপি সহ নির্ভুলতার জন্য নম্পি এবং তুলনা ব্যবহার করে সাধারণ সমাধান এখানে দেওয়া হয়েছে:

ডেটা প্রস্তুতি:

import numpy as np

np.random.seed(2019)

batch_size = 1
n_items = 3
n_classes = 2
logits_np = np.random.rand(batch_size,n_items,n_classes).astype(np.float32)
print('logits_np.shape', logits_np.shape)
print('logits_np:')
print(logits_np)

আউটপুট:

logits_np.shape (1, 3, 2)
logits_np:
[[[0.9034822  0.3930805 ]
  [0.62397    0.6378774 ]
  [0.88049906 0.299172  ]]]

টেনসরফ্লো ব্যবহার করে সফটম্যাক্স:

import tensorflow as tf

logits_tf = tf.convert_to_tensor(logits_np, np.float32)
scores_tf = tf.nn.softmax(logits_np, axis=-1)

print('logits_tf.shape', logits_tf.shape)
print('scores_tf.shape', scores_tf.shape)

with tf.Session() as sess:
    scores_np = sess.run(scores_tf)

print('scores_np.shape', scores_np.shape)
print('scores_np:')
print(scores_np)

print('np.sum(scores_np, axis=-1).shape', np.sum(scores_np,axis=-1).shape)
print('np.sum(scores_np, axis=-1):')
print(np.sum(scores_np, axis=-1))

আউটপুট:

logits_tf.shape (1, 3, 2)
scores_tf.shape (1, 3, 2)
scores_np.shape (1, 3, 2)
scores_np:
[[[0.62490064 0.37509936]
  [0.4965232  0.5034768 ]
  [0.64137274 0.3586273 ]]]
np.sum(scores_np, axis=-1).shape (1, 3)
np.sum(scores_np, axis=-1):
[[1. 1. 1.]]

স্কিপি ব্যবহার করে সফটম্যাক্স:

from scipy.special import softmax

scores_np = softmax(logits_np, axis=-1)

print('scores_np.shape', scores_np.shape)
print('scores_np:')
print(scores_np)

print('np.sum(scores_np, axis=-1).shape', np.sum(scores_np, axis=-1).shape)
print('np.sum(scores_np, axis=-1):')
print(np.sum(scores_np, axis=-1))

আউটপুট:

scores_np.shape (1, 3, 2)
scores_np:
[[[0.62490064 0.37509936]
  [0.4965232  0.5034768 ]
  [0.6413727  0.35862732]]]
np.sum(scores_np, axis=-1).shape (1, 3)
np.sum(scores_np, axis=-1):
[[1. 1. 1.]]

সফটম্যাক্স নমপি ব্যবহার করে ( https://nolanbconaway.github.io/blog/2017/softmax-numpy ):

def softmax(X, theta = 1.0, axis = None):
    """
    Compute the softmax of each element along an axis of X.

    Parameters
    ----------
    X: ND-Array. Probably should be floats.
    theta (optional): float parameter, used as a multiplier
        prior to exponentiation. Default = 1.0
    axis (optional): axis to compute values along. Default is the
        first non-singleton axis.

    Returns an array the same size as X. The result will sum to 1
    along the specified axis.
    """

    # make X at least 2d
    y = np.atleast_2d(X)

    # find axis
    if axis is None:
        axis = next(j[0] for j in enumerate(y.shape) if j[1] > 1)

    # multiply y against the theta parameter,
    y = y * float(theta)

    # subtract the max for numerical stability
    y = y - np.expand_dims(np.max(y, axis = axis), axis)

    # exponentiate y
    y = np.exp(y)

    # take the sum along the specified axis
    ax_sum = np.expand_dims(np.sum(y, axis = axis), axis)

    # finally: divide elementwise
    p = y / ax_sum

    # flatten if X was 1D
    if len(X.shape) == 1: p = p.flatten()

    return p


scores_np = softmax(logits_np, axis=-1)

print('scores_np.shape', scores_np.shape)
print('scores_np:')
print(scores_np)

print('np.sum(scores_np, axis=-1).shape', np.sum(scores_np, axis=-1).shape)
print('np.sum(scores_np, axis=-1):')
print(np.sum(scores_np, axis=-1))

আউটপুট:

scores_np.shape (1, 3, 2)
scores_np:
[[[0.62490064 0.37509936]
  [0.49652317 0.5034768 ]
  [0.64137274 0.3586273 ]]]
np.sum(scores_np, axis=-1).shape (1, 3)
np.sum(scores_np, axis=-1):
[[1. 1. 1.]]

Answer 22

সফটম্যাক্স ফাংশন একটি অ্যাক্টিভেশন ফাংশন যা সংখ্যাকে সম্ভাব্যতায় রূপ দেয় যা একের সমষ্টি। সফটম্যাক্স ফাংশন এমন একটি ভেক্টরকে আউটপুট দেয় যা ফলাফলের তালিকার সম্ভাব্যতা বিতরণের প্রতিনিধিত্ব করে। এটি গভীর শিক্ষার শ্রেণিবদ্ধকরণ কার্যগুলিতে ব্যবহৃত একটি মূল উপাদান।

আমাদের একাধিক ক্লাস করার সময় সফটম্যাক্স ফাংশন ব্যবহৃত হয়।

এটি ক্লাসটি সর্বাধিক রয়েছে তা সন্ধানের জন্য দরকারী। সম্ভাব্যতা.

সফটম্যাক্স ফাংশনটি আদর্শভাবে আউটপুট স্তরে ব্যবহৃত হয়, যেখানে আমরা প্রতিটি ইনপুটের শ্রেণি সংজ্ঞায়নের জন্য সম্ভাব্যতা অর্জনের চেষ্টা করছি।

এটি 0 থেকে 1 এর মধ্যে রয়েছে।

সফটম্যাক্স ফাংশন লগইটগুলি [২.০, ১.০, ০.০] কে সম্ভাব্যতার মধ্যে পরিণত করে [০.০, ০.২, ০.০] এবং সম্ভাব্যতাগুলির যোগফল ১. লগইটস একটি নিউরাল নেটওয়ার্কের শেষ স্তর দ্বারা কাঁচা স্কোর আউটপুট। অ্যাক্টিভেশন স্থান গ্রহণের আগে Before সফটম্যাক্স ফাংশনটি বুঝতে, আমাদের অবশ্যই (n-1) তম স্তরের আউটপুটটি দেখতে হবে।

সফটম্যাক্স ফাংশন আসলে একটি আরগ সর্বাধিক ফাংশন। এর অর্থ হল যে এটি ইনপুট থেকে বৃহত্তম মানটি দেয় না, তবে বৃহত্তম মানগুলির অবস্থান।

উদাহরণ স্বরূপ:

সফটম্যাক্সের আগে

X = [13, 31, 5]

সফটম্যাক্স পরে

array([1.52299795e-08, 9.99999985e-01, 5.10908895e-12]

কোড:

import numpy as np

# your solution:

def your_softmax(x): 

"""Compute softmax values for each sets of scores in x.""" 

e_x = np.exp(x - np.max(x)) 

return e_x / e_x.sum() 

# correct solution: 

def softmax(x): 

"""Compute softmax values for each sets of scores in x.""" 

e_x = np.exp(x - np.max(x)) 

return e_x / e_x.sum(axis=0) 

# only difference