একটি নিউরাল নেটওয়ার্ক প্রাইমগুলি চিনতে পারে?

Question

পটভূমি

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

আরও স্পষ্টভাবে, কারণ এটি একটি প্রোগ্রামিং ওয়েবসাইট, আসুন 2 ^ 20 = 1,048,576 এ যান। এই প্রান্তিকের নীচে প্রাইমের সংখ্যা 82,025 বা মোটামুটি 8%।

চ্যালেঞ্জ

নিউরাল নেটওয়ার্কের মধ্যে আপনি কতটা ছোট খুঁজে পেতে পারেন যে সমস্ত 20-বিট পূর্ণসংখ্যাকে সঠিকভাবে প্রধান হিসাবে বা প্রধান হিসাবে শ্রেণিবদ্ধ করে?

এই চ্যালেঞ্জের উদ্দেশ্যে, নিউরাল নেটওয়ার্কের আকার হ'ল এটি উপস্থাপনের জন্য প্রয়োজনীয় মোট ওজন এবং বায়াসগুলির সংখ্যা।

বিস্তারিত

লক্ষ্যটি হ'ল একক, সুস্পষ্ট নিউরাল নেটওয়ার্কের আকার হ্রাস করা ।

আপনার নেটওয়ার্কের ইনপুটটি দৈর্ঘ্যের 20 এর ভেক্টর হবে যা কোনও পূর্ণসংখ্যার পৃথক বিট যুক্ত 0 বা 1s বা বিকল্পভাবে -1 এবং + 1 এর সাথে উপস্থাপিত হয়। এর ক্রমটি সবচেয়ে গুরুত্বপূর্ণ-বিট প্রথম বা সর্বনিম্ন-তাত্পর্যপূর্ণ-বিট প্রথম হতে পারে।

আপনার নেটওয়ার্কের আউটপুটটি একক সংখ্যা হওয়া উচিত, যেমন কিছু কাটফের উপরে ইনপুটটি প্রাইম হিসাবে স্বীকৃত হয় এবং একই কাটঅফের নীচে ইনপুটটি প্রাইম নয় হিসাবে স্বীকৃত হয়। উদাহরণস্বরূপ, ধনাত্মকটির অর্থ প্রধান (এবং নেতিবাচক প্রাইম নয়) হতে পারে, বা বিকল্পটি 0.5 এর চেয়ে বেশি হতে পারে প্রধান (এবং 0.5 এর চেয়ে কম প্রধানমন্ত্রী নয়)।

নেটওয়ার্কটি সমস্ত 2 ^ 20 = 1,048,576 সম্ভাব্য ইনপুটগুলিতে অবশ্যই 100% নির্ভুল হতে হবে। উপরে উল্লিখিত হিসাবে, নোট করুন যে এই ব্যাপ্তিতে 82,025 টি প্রাইম রয়েছে। (এটি অনুসরণ করে যে সর্বদা "প্রাইম নয়" আউটপুটিং 92% সঠিক হবে))

স্ট্যান্ডার্ড নিউরাল নেটওয়ার্ক পরিভাষার ক্ষেত্রে, এটি সম্ভবত ওভারফিটিং বলা হবে । অন্য কথায়, আপনার লক্ষ্যটি প্রাইমগুলিকে পুরোপুরি মানিয়ে নেওয়া। অন্য যে কোনও শব্দ ব্যবহার করতে পারে তা হ'ল "প্রশিক্ষণ সেট" এবং "পরীক্ষার সেট" একই are

এই চ্যালেঞ্জটি "প্রশিক্ষণযোগ্য" বা "শেখার যোগ্য" পরামিতিগুলির সংখ্যা বিবেচনা করে না। প্রকৃতপক্ষে, আপনার নেটওয়ার্কটিতে হার্ড-কোডিং ওজন থাকতে পারে এবং নীচের উদাহরণটি পুরোপুরি হার্ড-কোডড। পরিবর্তে, সমস্ত ওজন এবং পক্ষপাত বিবেচনা করা হয় এবং গণনা করা হয়।

আপনার নিউরাল নেটওয়ার্ক প্রশিক্ষণ বা জেনারেট করার জন্য প্রয়োজনীয় কোডের দৈর্ঘ্যটি আপনার স্কোরের সাথে প্রাসঙ্গিক নয় তবে প্রাসঙ্গিক কোড পোস্ট করা অবশ্যই প্রশংসিত হয়।

বেসলাইন

বেসলাইন হিসাবে, 1,804,551 মোট ওজন এবং বায়াস সহ সমস্ত 82,025 টি প্রাইমকে "মুখস্থ" করা সম্ভব ।

নোট করুন যে এর পরে এই কোডটিতে অনেকগুলি বিষয় রয়েছে: একটি কার্যকারী উদাহরণ, ওয়ার্কিং টেস্ট কোড, পরিচিত নিউরাল লাইব্রেরি ব্যবহার করে নিউরাল নেটওয়ার্কের একটি কার্যকরী সংজ্ঞা, একটি "হার্ড-কোডড" (বা কমপক্ষে, "প্রশিক্ষিত নয়") নিউরাল নেটওয়ার্ক, এবং স্কোর একটি কাজের পরিমাপ।

import numpy as np

bits = 20

from keras.models import Sequential
from keras.layers import Dense

from sympy import isprime

# Hardcode some weights
weights = []
biases  = []
for n in xrange(1<<bits):
    if not isprime(n):
        continue
    bit_list = [(n / (1 << i))%2 for i in xrange(bits)]
    weight = [2*bit - 1 for bit in bit_list]
    bias   = - (sum(bit_list) - 1)
    weights.append(weight)
    biases .append(bias)
nprimes = len(biases)
weights1 = np.transpose(np.array(weights))
biases1  = np.array(biases )
weights2 = np.full( (nprimes,1), 1 )
biases2  = np.array( [0] )

model = Sequential()
model.add(Dense(units=nprimes, activation='relu', input_dim=bits, weights=[weights1, biases1]))
model.add(Dense(units=1, activation='relu', weights=[weights2, biases2]))
print "Total weights and biases: {}".format( np.size(weights1) + np.size(weights2) + np.size(biases1) + np.size(biases2) )

# Evaluate performance
x = []
y = []
for n in xrange(1<<bits):
    row = [(n / (1 << i))%2 for i in xrange(bits)]
    x.append( row )
    col = 0
    if isprime(n):
        col = 1
    y.append( col )
x = np.array(x)
y = np.array(y)

model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])

loss, accuracy = model.evaluate(x, y, batch_size=256)
if accuracy == 1.0:
    print "Perfect fit."
else:
    print "Made at least one mistake."

নিউরাল নেটওয়ার্ক কী?

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

একটি ফিডফোরওয়ার্ড নিউরাল নেটওয়ার্ক হল নিউরনের স্তরগুলির সংগ্রহ । ইনপুট লেয়ারে 20 টি নিউরন, এক বা একাধিক লুকানো স্তরগুলিতে কিছু সংখ্যক নিউরন এবং আউটপুট স্তরে 1 নিউরনের সাথে লেয়ার প্রতি নিউরনের সংখ্যা পরিবর্তিত হয়। (কমপক্ষে একটি লুকানো স্তর থাকা আবশ্যক কারণ প্রাইমগুলি এবং নন-প্রাইমগুলি তাদের বিট নিদর্শন অনুসারে রৈখিকভাবে পৃথক নয়)) উপরের বেসলাইন উদাহরণে স্তরগুলির মাপ [20, 82025, 1]]

ইনপুট নিউরনের মানগুলি ইনপুট দ্বারা নির্ধারিত হয়। উপরে বর্ণিত হিসাবে এটি হয় 0 এবং 2 ^ 20 এর মধ্যে কোনও সংখ্যার বিটের সাথে একইভাবে 0 এবং 1 গুলি হবে, বা -1 এবং 1+ একইভাবে হবে।

আউটপুট স্তর সহ প্রতিটি নীচের নিউরনের মানগুলি স্তর থেকে আগে থেকেই নির্ধারিত হয়। প্রথমে সম্পূর্ণরূপে সংযুক্ত বা ঘন ফ্যাশনে একটি লিনিয়ার ফাংশন প্রয়োগ করা হয় । এই জাতীয় ফাংশন উপস্থাপনের একটি পদ্ধতি হ'ল ওয়েট ম্যাট্রিক্স ব্যবহার করা । উদাহরণস্বরূপ, বেসলাইনের প্রথম দুটি স্তরের মধ্যে স্থানান্তরগুলি 82025 x 20 ম্যাট্রিক্সের সাথে প্রতিনিধিত্ব করা যেতে পারে। ওজনের সংখ্যা হ'ল এই ম্যাট্রিক্সে প্রবেশের সংখ্যা, যেমন 1640500 Then এটি কোনও ভেক্টর দ্বারা প্রতিনিধিত্ব করা যেতে পারে, যেমন আমাদের ক্ষেত্রে একটি 82025 x 1 ম্যাট্রিক্স। গোঁড়ামির সংখ্যা এন্ট্রির সংখ্যা, উদাঃ 82025. হয় (নোট যে ওজন এবং একসঙ্গে গোঁড়ামির একটি বর্ণনা ফাংশন রৈখিক অ্যাফিন ।)

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

অবশেষে, অ্যাক্টিভেশন ফাংশন নামক একটি ননলাইনার ফাংশন এই এফাইন লিনিয়ার ফাংশনের ফলাফলের জন্য প্রবেশ অনুসারে প্রয়োগ করা হয়। এই সংকীর্ণ সংজ্ঞাটির উদ্দেশ্যে, অনুমোদিত অ্যাক্টিভেশন ফাংশনগুলি হ'ল রিলু , তানহ এবং সিগময়েড । পুরো স্তরটিকে একই অ্যাক্টিভেশন ফাংশনটি ব্যবহার করতে হবে।

বেসলাইন উদাহরণে, ওজনের সংখ্যা 20 * 82025 + 82025 * 1 = 1722525 এবং পক্ষপাতের সংখ্যা 82025 + 1 = 82026, মোট স্কোরের জন্য 1722525 + 82026 = 1804551. একটি প্রতীকী উদাহরণ হিসাবে, যদি সেখানে থাকত এর পরিবর্তে আরও একটি স্তর এবং স্তর আকার ছিল [20, a, b, 1], তারপরে ওজনের সংখ্যা 20 * a + a * b + b * 1 হবে এবং পক্ষপাতের সংখ্যাটি একটি + বি + 1 হবে।

নিউরাল নেটওয়ার্কের এই সংজ্ঞা কেরাস , সাইকিট-লার্ন , এবং টেনসরফ্লো সহ অনেকগুলি ফ্রেমওয়ার্ক দ্বারা ভাল-সমর্থনযোগ্য । উপরের বেসলাইন উদাহরণে কেরাস ব্যবহার করা হয়েছে, মূলত কোড সহ নিম্নরূপ:

from keras.models import Sequential
model = Sequential()
from keras.layers import Dense
model.add(Dense(units=82025, activation='relu', input_dim=20, weights=[weights1, biases1]))
model.add(Dense(units=1, activation='relu', weights=[weights2, biases2]))
score = numpy.size(weights1) + numpy.size(biases1) + numpy.size(weights2) + numpy.size(biases2)

যদি ওজন এবং বায়াস ম্যাট্রিকগুলি নমপি অ্যারে হয়, তবে numpy.size আপনাকে সরাসরি এন্ট্রিগুলির সংখ্যা বলবে।

অন্যান্য ধরণের নিউরাল নেটওয়ার্ক রয়েছে কি?

আপনি যদি এই চ্যালেঞ্জের উদ্দেশ্যে নিউরাল নেটওয়ার্ক এবং স্কোরের একক, সুনির্দিষ্ট সংজ্ঞা চান, তবে দয়া করে পূর্ববর্তী বিভাগে সংজ্ঞাটি ব্যবহার করুন। আপনি যদি মনে করেন যে "যে কোনও ফাংশন" সঠিকভাবে দেখেছে এটি একটি নিউরাল নেটওয়ার্ক যার কোনও পরামিতি নেই , তবে দয়া করে পূর্ববর্তী বিভাগে সংজ্ঞাটি ব্যবহার করুন।

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

Comments

এই ওজন কি ধরণের? সাধারণত লোকেরা ফ্লোট ব্যবহার করে আমরা কি অন্যান্য সংখ্যার প্রকার ব্যবহার করতে পারি? যেমন কম, আরও বা সীমাহীন নির্ভুলতার প্রকারগুলি।

— গম উইজার্ড

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

— এ। রেক্স

আমি এই প্রশ্নটি ভালবাসি তবে হতাশ হয়েছি যে পর্যাপ্ত প্রশিক্ষণের সময় খুঁজে পাওয়ার মতো খুব বেশি ছোট নিউরাল নেটওয়ার্ক নেই।

— আনুশ

Answer 1

ট্রায়াল বিভাগ: স্কোর 59407, 6243 স্তর, মোট 16478 নিউরন

পাইথন প্রোগ্রাম হিসাবে দেওয়া যা নেট উত্পন্ন এবং বৈধ করে। trial_divisionএটি কীভাবে কাজ করে তার ব্যাখ্যার জন্য মন্তব্যগুলি দেখুন । বৈধতাটি বেশ ধীর (যেমন চলমান সময় কয়েক ঘন্টা পরিমাপ করা হয়): আমি পাইপাই বা সিথন ব্যবহারের পরামর্শ দিই।

$\alpha \to \max(0, \alpha)$

প্রান্তিক স্তরটি হ'ল 1: উপরে যে কোনও কিছুই প্রধান, নীচের যে কোনও কিছু সংমিশ্রিত বা শূন্য এবং একমাত্র ইনপুট যা 1 আউটপুট দেয় সে নিজেই 1।

#!/usr/bin/python3

import math


def primes_to(n):
    ps = []
    for i in range(2, n):
        is_composite = False
        for p in ps:
            if i % p == 0:
                is_composite = True
                break
            if p * p > i:
                break
        if not is_composite:
            ps.append(i)
    return ps


def eval_net(net, inputs):
    for layer in net:
        inputs.append(1)
        n = len(inputs)
        inputs = [max(0, sum(inputs[i] * neuron[i] for i in range(n))) for neuron in layer]
    return inputs


def cost(net):
    return sum(len(layer) * len(layer[0]) for layer in net)


def trial_division(num_bits):
    # Overview: we convert the bits to a single number x and perform trial division.
    # x is also our "is prime" flag: whenever we prove that x is composite, we clear it to 0
    # At the end x will be non-zero only if it's a unit or a prime, and greater than 1 only if it's a prime.
    # We calculate x % p as
    #     rem = x - (x >= (p << a) ? 1 : 0) * (p << a)
    #     rem -= (rem >= (p << (a-1)) ? 1) : 0) * (p << (a-1))
    #     ...
    #     rem -= (rem >= p ? 1 : 0) * p
    #
    # If x % p == 0 and x > p then x is a composite multiple of p and we want to set it to 0

    N = 1 << num_bits
    primes = primes_to(1 + int(2.0 ** (num_bits / 2)))

    # As a micro-optimisation we exploit 2 == -1 (mod 3) to skip a number of shifts for p=3.
    # We need to bias by a multiple of 3 which is at least num_bits // 2 so that we don't get a negative intermediate value.
    bias3 = num_bits // 2
    bias3 += (3 - (bias3 % 3)) % 3

    # inputs: [bit0, ..., bit19]
    yield [[1 << i for i in range(num_bits)] + [0],
           [-1] + [0] * (num_bits - 1) + [1],
           [0] * 2 + [-1] * (num_bits - 2) + [1],
           [(-1) ** i for i in range(num_bits)] + [bias3]]

    for p in primes[1:]:
        # As a keyhole optimisation we overlap the cases slightly.
        if p == 3:
            # [x, x_is_even, x_lt_4, x_reduced_mod_3]
            max_shift = int(math.log((bias3 + (num_bits + 1) // 2) // p, 2))
            yield [[1, 0, 0, 0, 0], [0, 1, -1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, -1, p << max_shift]]
            yield [[1, -N, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, -1, 1]]
            yield [[1, 0, 0, 0], [0, 1, -p << max_shift, 0]]
        else:
            # [x, x % old_p]
            max_shift = int(num_bits - math.log(p, 2))
            yield [[1, 0, 0], [1, -N, -p_old], [-1, 0, p << max_shift]]
            yield [[1, -N, 0, 0], [0, 0, -1, 1]]
            yield [[1, 0, 0], [1, -p << max_shift, 0]]

        for shift in range(max_shift - 1, -1, -1):
            # [x, rem]
            yield [[1, 0, 0], [0, 1, 0], [0, -1, p << shift]]
            yield [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 1]]
            yield [[1, 0, 0, 0], [0, 1, -p << shift, 0]]
        # [x, x % p]
        p_old = p

    yield [[1, 0, 0], [1, -N, -p]]
    yield [[1, -N, 0]]


def validate_primality_tester(primality_tester, threshold):
    num_bits = len(primality_tester[0][0]) - 1
    primes = set(primes_to(1 << num_bits))
    errors = 0
    for i in range(1 << num_bits):
        expected = i in primes
        observed = eval_net(primality_tester, [(i >> shift) & 1 for shift in range(num_bits)])[-1] > threshold
        if expected != observed:
            errors += 1
            print("Failed test case", i)
        if (i & 0xff) == 0:
            print("Progress", i)

    if errors > 0:
        raise Exception("Failed " + str(errors) + " test case(s)")


if __name__ == "__main__":
    n = 20

    trial_div = list(trial_division(n))
    print("Cost", cost(trial_div))
    validate_primality_tester(trial_div, 1)

---

একদিকে যেমন, আবার

সর্বজনীন আনুমানিক উপপাদ্যটি বলে যে নিউরাল নেটওয়ার্কগুলি যে কোনও ধ্রুবক ফাংশন আনুমানিক করতে পারে

এটি সহজেই দেখাতে পারে যে রিলু ব্যবহার করে একটি নিউরাল নেটওয়ার্ক টিউরিং সম্পূর্ণ। দৃ implement়ভাবে প্রয়োগের জন্য সহজতম লজিক গেটটি হল উত্তর: একটি এন-ইনপুট এনওআর গেটটি । আমি দৃust়তার সাথে বলছি কারণ এই গেটটি 1 টিরও বেশি ইনপুট গ্রহণ করে তবে (প্রদত্ত ইনপুটগুলি 0 এবং 1 এর মধ্যে নয়) কেবল কখনও 0 বা 1 আউটপুট দেয় A একক স্তর এবং গেটটি তবে কেবলমাত্র সঠিকভাবে কাজ করে যদি এর ইনপুটগুলি 0 বা 1 হওয়ার গ্যারান্টিযুক্ত হয় এবং বৃহত্তর সংখ্যার আউটপুট দিতে পারে। অন্যান্য স্তরের এক স্তরে সম্ভব, তবে কেবল নিজেই টুরিং-সম্পূর্ণ তাই বিশদে যাওয়ার দরকার নেই।$\max\left(0, 1 - \sum a_i\right)$ সর্বোচ্চ ( 0 , 1 + + Σ ( একটি আমি - 1 ) )$\max\left(0, 1 + \sum(a_i - 1)\right)$

Comments

আরও কিছুটা বাদ দিয়ে, আমি বিচার বিভাগের চেষ্টা করার আগে আমি অয়লার টেস্টে কাজ শুরু করেছিলাম, কারণ আমি ভেবেছিলাম এটি আরও দক্ষ হবে, তবে একটি সংখ্যা বাড়ানো (7 সেরা প্রার্থী ছিল) (x- (x মড 2) এর একটি শক্তিতে ) হ্রাস মোড x এর পরে 38 গুনের প্রয়োজন হবে এবং 20-বিট সংখ্যার গুণমানের জন্য আমি খুঁজে পেয়েছি সেরা নেটওয়ার্কের দাম 1135, সুতরাং এটি প্রতিযোগিতামূলক হতে চলেছে না।

— পিটার টেলর

Answer 2

স্কোর 984314, 82027 স্তর, মোট 246076 নিউরন

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

একটি ইনপুট যা একটি পূর্ণসংখ্যা হিসাবে পরিচিত, আমরা পরীক্ষা করতে পারি দুটি স্তর এবং তিনটি নিউরন সহ:$x$$x = a$

1. $\textrm{ge}_a = (x - a)^+$$\textrm{le}_a = (-x + a)^+$
2. $\textrm{eq}_a = (-\textrm{ge}_a - \textrm{le}_a + 1)^+$$\textrm{eq}_{a}$$1$$x = a$$0$

---

$x$

$\textrm{ge}_2 = (x - 2)^+$$\textrm{le}_2 = (-x + 2)^+$

$\textrm{accum}_2 = (-\textrm{ge}_2 - \textrm{le}_2 + 1)^+$$\textrm{ge}_3 = (\textrm{ge}_2 - (3-2))^+$$\textrm{le}_3 = (-\textrm{ge}_2 + (3-2))^+$

$\textrm{accum}_3 = (2^{21} \textrm{accum}_2 -\textrm{ge}_3 - \textrm{le}_3 + 1)^+$$\textrm{ge}_5 = (\textrm{ge}_3 - (5-3))^+$$\textrm{le}_5 = (-\textrm{ge}_3 + (5-3))^+$

$\textrm{accum}_5 = (2^{21} \textrm{accum}_3 -\textrm{ge}_5 - \textrm{le}_5 + 1)^+$$\textrm{ge}_7 = (\textrm{ge}_5 - (7-5))^+$$\textrm{le}_7 = (-\textrm{ge}_5 + (7-5))^+$

...

স্তর 82026: আউটপুট $\textrm{accum}_{1048571} = (2^{21} \textrm{accum}_{1048559} -\textrm{ge}_{1048571} - \textrm{le}_{1048571} + 1)^+$$\textrm{ge}_{1048573} = (\textrm{ge}_{1048571} - ({1048573}-{1048571}))^+$$\textrm{le}_{1048573} = (-\textrm{ge}_{1048571} + ({1048573}-{1048571}))^+$

$\textrm{accum}_{1048573} = (2^{21} \textrm{accum}_{1048571} -\textrm{ge}_{1048573} - \textrm{le}_{1048573} + 1)^+$

$+\infty$

স্কোরটি (82026 - 3) * 12 + 21 + 4 + 9 + 4।

Comments

কুল। আমি যেমন বুঝতে পারি, এটি প্রাইমগুলিকে "মুখস্থ" করে, তবে এটি "সমান্তরাল" না হয়ে "ধারাবাহিকভাবে" সমতার জন্য পরীক্ষা করে। (বিকল্পভাবে, এটি বেসলাইনের ট্রান্সপোজের মতো)) প্রথম পদক্ষেপটি হ'ল বিট প্যাটার্নটি তত্ক্ষণাত্ সরিয়ে নেওয়া এবং কেবল প্রকৃত পূর্ণসংখ্যার সাথে কাজ করা। ফলস্বরূপ, সাম্যতা পরীক্ষায় 20-গুণ পেনাল্টি নেই। আপনার জমা দেওয়ার জন্য ধন্যবাদ

— এ রেক্স

সুপারস্ক্রিপ্ট প্লাস কি?

— ফেয়ারস

$x^+ = \max(0, x)$