row_id
int64 0
48.4k
| init_message
stringlengths 1
342k
| conversation_hash
stringlengths 32
32
| scores
dict |
|---|---|---|---|
37,947
|
I am working on RL model using DDPG method , where I have inhereted Gym environment to create a environment having continuous spaces and action where two element clashes to each other like replicating in Revit MEP clash , I am moming clash element from each other in such a way that euclidean distance lie in a specific range to assume it resolved clashes . My code is working fine .
Now I want to make it more general where there are multiple clashes, then how to work on it.
import gymnasium as gym
import tensorflow as tf
import numpy as np
# Define constants
num_states = 4 # Number of features defining the state
num_actions = 6 # Number of possible resolution actions
upper_bound = -10 # Maximum value for resolution actions
lower_bound = 10 # Minimum value for resolution actions
# Define the Ornstein-Uhlenbeck noise process
class OUActionNoise:
def __init__(self, mean, std_deviation, theta=0.15, dt=1e-2, x_initial=None):
self.theta = theta
self.mean = mean
self.std_dev = std_deviation
self.dt = dt
self.x_initial = x_initial
self.reset()
def __call__(self):
x = (
self.x_prev
+ self.theta * (self.mean - self.x_prev) * self.dt
+ self.std_dev * np.sqrt(self.dt) * np.random.normal(size=self.mean.shape)
)
self.x_prev = x
return x
def reset(self):
if self.x_initial is not None:
self.x_prev = self.x_initial
else:
self.x_prev = np.zeros_like(self.mean)
# Define the Buffer class for experience replay
class Buffer:
def __init__(self, buffer_capacity=100000, batch_size=64):
self.buffer_capacity = buffer_capacity
self.batch_size = batch_size
self.buffer_counter = 0
self.state_buffer = np.zeros((self.buffer_capacity, num_states))
self.action_buffer = np.zeros((self.buffer_capacity, num_actions))
self.reward_buffer = np.zeros((self.buffer_capacity, 1))
self.next_state_buffer = np.zeros((self.buffer_capacity, num_states))
def record(self, obs_tuple):
print('obs_tuple================================',obs_tuple)
index = self.buffer_counter % self.buffer_capacity
print('====buffer_counter , buffer_capicity, index========',self.buffer_counter, self.buffer_capacity, index)
self.state_buffer[index] = obs_tuple[0]
self.action_buffer[index] = obs_tuple[1]
self.reward_buffer[index] = obs_tuple[2]
self.next_state_buffer[index] = obs_tuple[3]
self.buffer_counter += 1
@tf.function
def update(self, state_batch, action_batch, reward_batch, next_state_batch):
with tf.GradientTape() as tape:
target_actions = target_actor(next_state_batch, training=True)
y = reward_batch + gamma * target_critic(
[next_state_batch, target_actions], training=True
)
critic_value = critic_model([state_batch, action_batch], training=True)
critic_loss = tf.math.reduce_mean(tf.math.square(y - critic_value))
critic_grad = tape.gradient(critic_loss, critic_model.trainable_variables)
critic_optimizer.apply_gradients(
zip(critic_grad, critic_model.trainable_variables)
)
with tf.GradientTape() as tape:
actions = actor_model(state_batch, training=True)
critic_value = critic_model([state_batch, actions], training=True)
actor_loss = -tf.math.reduce_mean(critic_value)
actor_grad = tape.gradient(actor_loss, actor_model.trainable_variables)
actor_optimizer.apply_gradients(
zip(actor_grad, actor_model.trainable_variables)
)
def learn(self):
record_range = min(self.buffer_counter, self.buffer_capacity)
batch_indices = np.random.choice(record_range, self.batch_size)
state_batch = tf.convert_to_tensor(self.state_buffer[batch_indices])
action_batch = tf.convert_to_tensor(self.action_buffer[batch_indices])
reward_batch = tf.convert_to_tensor(self.reward_buffer[batch_indices])
reward_batch = tf.cast(reward_batch, dtype=tf.float32)
next_state_batch = tf.convert_to_tensor(self.next_state_buffer[batch_indices])
self.update(state_batch, action_batch, reward_batch, next_state_batch)
# Define the update_target function for updating target networks
@tf.function
def update_target(target_weights, weights, tau):
for (a, b) in zip(target_weights, weights):
a.assign(b * tau + a * (1 - tau))
# Define the actor and critic neural networks
def get_actor():
last_init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003)
inputs = tf.keras.layers.Input(shape=(num_states,))
out = tf.keras.layers.Dense(256, activation="relu")(inputs)
out = tf.keras.layers.Dense(256, activation="relu")(out)
outputs = tf.keras.layers.Dense(6, activation="tanh", kernel_initializer=last_init)(out)
outputs = outputs * upper_bound
model = tf.keras.Model(inputs, outputs)
return model
def get_critic():
state_input = tf.keras.layers.Input(shape=(num_states,))
state_out = tf.keras.layers.Dense(16, activation="relu")(state_input)
state_out = tf.keras.layers.Dense(32, activation="relu")(state_out)
action_input = tf.keras.layers.Input(shape=(num_actions,))
action_out = tf.keras.layers.Dense(32, activation="relu")(action_input)
concat = tf.keras.layers.Concatenate()([state_out, action_out])
out = tf.keras.layers.Dense(256, activation="relu")(concat)
out = tf.keras.layers.Dense(256, activation="relu")(out)
outputs = tf.keras.layers.Dense(1)(out)
model = tf.keras.Model([state_input, action_input], outputs)
return model
# Define the policy function
def policy(state, noise_object):
sampled_actions = tf.squeeze(actor_model(state))
noise = noise_object()
sampled_actions = sampled_actions.numpy() + noise
legal_action = np.clip(sampled_actions, lower_bound, upper_bound)
#return [np.squeeze(legal_action)]
return np.squeeze(legal_action)
# Define DDPG hyperparameters
std_dev = 0.2
ou_noise = OUActionNoise(mean=np.zeros(1), std_deviation=float(std_dev) * np.ones(1))
actor_model = get_actor()
critic_model = get_critic()
target_actor = get_actor()
target_critic = get_critic()
target_actor.set_weights(actor_model.get_weights())
target_critic.set_weights(critic_model.get_weights())
critic_lr = 0.002
actor_lr = 0.001
critic_optimizer = tf.keras.optimizers.Adam(critic_lr)
actor_optimizer = tf.keras.optimizers.Adam(actor_lr)
total_episodes = 100 # 100
gamma = 0.99
tau = 0.005
buffer = Buffer(50000, 64)
class ConstructionEnvironment(gym.Env):
def __init__(self, num_states, num_actions, lower_bound, upper_bound, max_episode_steps):
super(ConstructionEnvironment, self).__init__()
# Define action and observation spaces
self.action_space = gym.spaces.Box(low=lower_bound, high=upper_bound, shape=(num_actions,), dtype=np.float32)
self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(num_states,), dtype=np.float32)
# Initialize the state
self.state = np.zeros(num_states)
# Episode-related variables
self.episode_steps = 0
self.max_episode_steps = max_episode_steps
self.max_distance = np.sqrt(num_states) # Maximum Euclidean distance for normalization
def reset(self):
# Reset the state and episode steps
self.state = np.random.uniform(low=-1, high=1, size=self.observation_space.shape)
self.episode_steps = 0
return self.state
def step(self, action):
# Implement the actual step function based on your application
# Update the state, calculate reward, and check if the episode is done
self.episode_steps += 1
# Update state (simple example: add random noise to each state element)
self.state += np.random.normal(0, 0.1, size=self.observation_space.shape)
# Placeholder for reward calculation - maximize the negative Euclidean distance from the origin
reward = -np.linalg.norm(self.state) / self.max_distance
reward = self.calculate_reward(action) # Replace with your reward calculation
done = (self.episode_steps >= self.max_episode_steps) or (reward == 10)
return self.state, reward, done, {}
def calculate_reward(self,action):
reward = -0.5
# Example: Simple reward calculation based on the current state
# Replace this with your actual reward calculation logic
print('action=======inside Revit===========',action)
# data = np.array([-1.0, -1.0, 1.0, 1.0, 0.71324176, -1.0])
data = action
# Extract positions of element1 and element2
element1_position = data[:3]
element2_position = data[3:]
# Calculate Euclidean distance
euclidean_distance = np.linalg.norm(element1_position - element2_position)
# Print the result
print("Euclidean Distance:", euclidean_distance)
euclidian_d.append(euclidean_distance)
if 1.4 <= euclidean_distance <= 1.6:
reward = 10
# return -np.sum(np.square(self.state))
return reward
# Example of how to use the custom environment with specified parameters
num_states = 4
num_actions = 6
lower_bound = -1
upper_bound = 1
max_episode_steps = 200
env = ConstructionEnvironment(num_states=num_states, num_actions=num_actions, lower_bound=lower_bound, upper_bound=upper_bound, max_episode_steps=max_episode_steps)
env.max_episode_steps
# Train the DDPG model
reward_per_episode = []
def train_ddpg():
# env = ConstructionEnvironment()
for ep in range(total_episodes):
state = env.reset()
episodic_reward = 0
for i in range(env.max_episode_steps):
tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0)
action = policy(tf_state, ou_noise)
print('action==================&&&&&&&&&&&&====',type(action), action)
next_state, reward, done, _ = env.step(action)
# reward_data.append(reward)
print('next_state, reward, done, _====================',next_state, reward, done, _)
buffer.record((state, action, reward, next_state))
episodic_reward += reward
buffer.learn()
update_target(target_actor.variables, actor_model.variables, tau)
update_target(target_critic.variables, critic_model.variables, tau)
if done:
break
state = next_state
print("Episode * {} * Avg Reward ==> {}".format(ep, episodic_reward))
reward_per_episode.append(episodic_reward)
# Run the DDPG training
train_ddpg()
|
d6b35bb7fcc647551a0bae8fb3352a5b
|
{
"intermediate": 0.30688944458961487,
"beginner": 0.4494990110397339,
"expert": 0.24361149966716766
}
|
37,948
|
hi
|
da592f25ba84afa446db08253acdd77d
|
{
"intermediate": 0.3246487081050873,
"beginner": 0.27135494351387024,
"expert": 0.40399640798568726
}
|
37,949
|
business rule for total count of incident raised by logged in user in servicenow
|
ce6cb049caa939a02c805e2650c9cd68
|
{
"intermediate": 0.3754211664199829,
"beginner": 0.2831018269062042,
"expert": 0.34147703647613525
}
|
37,950
|
thymeleaf中，我希望多选下拉框被默认选中
<option th:each="itemOp: ${groupServiceSubscribersMap[item.groupService]}"
th:value="${itemOp.id}" th:text="${itemOp.name}" th:selected="${itemOp.id}"></option>
我希望${itemOp.id}在${item.subscriberConfigIds}列表之内
|
da42ca4e3599608fb11a3d709c42a2ac
|
{
"intermediate": 0.40826287865638733,
"beginner": 0.30884668231010437,
"expert": 0.2828904390335083
}
|
37,951
|
F:\react-blog-develop>git config --global https.proxy 'http://127.0.0.1:57635'
F:\react-blog-develop>git config --global http.proxy 'http://127.0.0.1:57635'
F:\react-blog-develop>git push -u origin main
fatal: unable to access 'https://github.com/zjrwtx/nextjsblog.git/': Unsupported proxy syntax in '127.0.0.1:57635'': Port number was not a decimal number between 0 and 65535
|
c49375677565f923d6e4678640b61732
|
{
"intermediate": 0.38089218735694885,
"beginner": 0.4008682668209076,
"expert": 0.21823953092098236
}
|
37,952
|
如何解决：
F:\smart-excel-ai-main>yarn dev
yarn run v1.22.21
$ next dev
'next' 不是内部或外部命令，也不是可运行的程序
或批处理文件。
error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
F:\smart-excel-ai-main>yarn install
yarn install v1.22.21
info No lockfile found.
[1/4] Resolving packages...
info There appears to be trouble with your network connection. Retrying...
warning contentlayer > @contentlayer/utils > memfs@3.6.0: this will be v4
warning logging-service > date-format@0.0.2: 0.x is no longer supported. Please upgrade to 4.x or higher.
[2/4] Fetching packages...
warning react-hook-form@7.49.3: The engine "pnpm" appears to be invalid.
[3/4] Linking dependencies...
warning "ai > swrv@1.0.4" has unmet peer dependency "vue@>=3.2.26 < 4".
warning "ai > sswr@2.0.0" has unmet peer dependency "svelte@^4.0.0".
warning "ai > solid-swr-store@0.10.7" has unmet peer dependency "solid-js@^1.2".
warning "contentlayer > @contentlayer/utils > @opentelemetry/exporter-trace-otlp-grpc > @opentelemetry/core@1.13.0" has incorrect peer dependency "@opentelemetry/api@>=1.0.0 <1.5.0".
warning "contentlayer > @contentlayer/utils > @opentelemetry/exporter-trace-otlp-grpc > @opentelemetry/resources@1.13.0" has incorrect peer dependency "@opentelemetry/api@>=1.0.0 <1.5.0".
warning "contentlayer > @contentlayer/utils > @opentelemetry/exporter-trace-otlp-grpc > @opentelemetry/sdk-trace-base@1.13.0" has incorrect peer dependency "@opentelemetry/api@>=1.0.0 <1.5.0".
warning "contentlayer > @contentlayer/utils > @opentelemetry/exporter-trace-otlp-grpc > @opentelemetry/otlp-transformer@0.39.1" has incorrect peer dependency "@opentelemetry/api@>=1.3.0 <1.5.0".
warning "contentlayer > @contentlayer/utils > @opentelemetry/exporter-trace-otlp-grpc > @opentelemetry/otlp-transformer > @opentelemetry/sdk-logs@0.39.1" has incorrect peer dependency "@opentelemetry/api@>=1.4.0 <1.5.0".
warning "contentlayer > @contentlayer/utils > @opentelemetry/exporter-trace-otlp-grpc > @opentelemetry/otlp-transformer > @opentelemetry/sdk-metrics@1.13.0" has incorrect peer dependency "@opentelemetry/api@>=1.3.0 <1.5.0".
warning "react-hot-toast > goober@2.1.14" has unmet peer dependency "csstype@^3.0.10".
warning " > rehype-pretty-code@0.10.2" has unmet peer dependency "shiki@0.x".
warning Workspaces can only be enabled in private projects.
warning Workspaces can only be enabled in private projects.
warning Workspaces can only be enabled in private projects.
warning Workspaces can only be enabled in private projects.
[4/4] Building fresh packages...
success Saved lockfile.
Done in 293.69s.
F:\smart-excel-ai-main>yarn dev
yarn run v1.22.21
$ next dev
Warning: Contentlayer might not work as expected on Windows
ConfigReadError (F:\smart-excel-ai-main\contentlayer.config.js): Error [ERR_MODULE_NOT_FOUND]: Cannot find package 'shiki' imported from F:\smart-excel-ai-main\node_modules\rehype-pretty-code\dist\rehype-pretty-code.js
ConfigReadError (F:\smart-excel-ai-main\contentlayer.config.js): Error [ERR_MODULE_NOT_FOUND]: Cannot find package 'shiki' imported from F:\smart-excel-ai-main\node_modules\rehype-pretty-code\dist\rehype-pretty-code.js
▲ Next.js 13.5.6
- Local: http://localhost:3000
✓ Ready in 4.5s
○ Compiling /(home)/page ...
✓ Compiled /(home)/page in 6.2s (1394 modules)
[next-auth][warn][NEXTAUTH_URL]
https://next-auth.js.org/warnings#nextauth_url
[next-auth][warn][NO_SECRET]
https://next-auth.js.org/warnings#no_secret
✓ Compiled in 782ms (534 modules)
✓ Compiled in 111ms (520 modules)
⨯ TypeError: Failed to parse URL from undefined
at getUsage (./lib/usage/usage.ts:58:19)
at Page (page.tsx:15:19)
Cause: TypeError: Invalid URL
at new URL (node:internal/url:775:36)
at new Request (node:internal/deps/undici/undici:5853:25)
at originFetch (F:\smart-excel-ai-main\node_modules\next\dist\compiled\next-server\webpack:\next\dist\compiled\react\cjs\react.shared-subset.development.js:237:81)
at doOriginalFetch (F:\smart-excel-ai-main\node_modules\next\dist\compiled\next-server\webpack:\next\dist\esm\server\lib\patch-fetch.js:319:24)
at fn (F:\smart-excel-ai-main\node_modules\next\dist\compiled\next-server\webpack:\next\dist\esm\server\lib\patch-fetch.js:452:20)
at F:\smart-excel-ai-main\node_modules\next\src\server\lib\trace\tracer.ts:268:28
at NoopContextManager.with (F:\smart-excel-ai-main\node_modules\@opentelemetry\api\src\context\NoopContextManager.ts:31:15)
at ContextAPI.with (F:\smart-excel-ai-main\node_modules\@opentelemetry\api\src\api\context.ts:77:42)
at NoopTracer.startActiveSpan (F:\smart-excel-ai-main\node_modules\@opentelemetry\api\src\trace\NoopTracer.ts:98:27)
at ProxyTracer.startActiveSpan (F:\smart-excel-ai-main\node_modules\@opentelemetry\api\src\trace\ProxyTracer.ts:51:20)
at F:\smart-excel-ai-main\node_modules\next\src\server\lib\trace\tracer.ts:245:32
at NoopContextManager.with (F:\smart-excel-ai-main\node_modules\@opentelemetry\api\src\context\NoopContextManager.ts:31:15)
at ContextAPI.with (F:\smart-excel-ai-main\node_modules\@opentelemetry\api\src\api\context.ts:77:42)
at NextTracerImpl.trace (F:\smart-excel-ai-main\node_modules\next\src\server\lib\trace\tracer.ts:244:28)
at globalThis.fetch (F:\smart-excel-ai-main\node_modules\next\dist\compiled\next-server\webpack:\next\dist\esm\server\lib\patch-fetch.js:136:34)
at we.request (webpack-internal:///(rsc)/./node_modules/@upstash/redis/chunk-F2WNH66D.mjs:56:23)
at X.exec (webpack-internal:///(rsc)/./node_modules/@upstash/redis/chunk-F2WNH66D.mjs:155:39)
at getUsage (webpack-internal:///(rsc)/./lib/usage/usage.ts:58:19)
at Page (webpack-internal:///(rsc)/./app/(home)/page.tsx:15:19) {
code: 'ERR_INVALID_URL',
input: 'undefined'
}
⨯ TypeError: Failed to parse URL from undefined
at getUsage (./lib/usage/usage.ts:58:19)
at Page (page.tsx:15:19)
digest: "3572731510"
Reload env: .env
⚠ Fast Refresh had to perform a full reload due to a runtime error.
✓ Compiled in 3.1s (1349 modules)
[next-auth][warn][NO_SECRET]
https://next-auth.js.org/warnings#no_secret
✓ Compiled /api/auth/[...nextauth] in 488ms (889 modules)
[next-auth][warn][NO_SECRET]
https://next-auth.js.org/warnings#no_secret
✓ Compiled /login/page in 828ms (1538 modules)
[next-auth][warn][NO_SECRET]
https://next-auth.js.org/warnings#no_secret
Reload env: .env
✓ Compiled in 498ms (1538 modules)
✓ Compiled in 355ms (1538 modules)
[next-auth][error][OAUTH_CALLBACK_ERROR]
https://next-auth.js.org/errors#oauth_callback_error connect ETIMEDOUT 20.205.243.166:443 {
error: Error: connect ETIMEDOUT 20.205.243.166:443
at TCPConnectWrap.afterConnect [as oncomplete] (node:net:1595:16)
at TCPConnectWrap.callbackTrampoline (node:internal/async_hooks:130:17) {
name: 'OAuthCallbackError',
code: 'ETIMEDOUT'
},
providerId: 'github',
message: 'connect ETIMEDOUT 20.205.243.166:443'
}
⨯ ./app/(about)/[...slug]/page.tsx:1:0
Module not found: Package path ./generated is not exported from package F:\smart-excel-ai-main\node_modules\contentlayer (see exports field in F:\smart-excel-ai-main\node_modules\contentlayer\package.json)
> 1 | import { allPosts } from "contentlayer/generated";
2 | import { notFound } from "next/navigation";
3 |
4 | import { Mdx } from "@/components/mdx/mdx-components";
https://nextjs.org/docs/messages/module-not-found
⨯ ./app/(about)/[...slug]/page.tsx:1:0
Module not found: Package path ./generated is not exported from package F:\smart-excel-ai-main\node_modules\contentlayer (see exports field in F:\smart-excel-ai-main\node_modules\contentlayer\package.json)
> 1 | import { allPosts } from "contentlayer/generated";
2 | import { notFound } from "next/navigation";
3 |
4 | import { Mdx } from "@/components/mdx/mdx-components";
https://nextjs.org/docs/messages/module-not-found
⨯ ./app/(about)/[...slug]/page.tsx:1:0
Module not found: Package path ./generated is not exported from package F:\smart-excel-ai-main\node_modules\contentlayer (see exports field in F:\smart-excel-ai-main\node_modules\contentlayer\package.json)
> 1 | import { allPosts } from "contentlayer/generated";
2 | import { notFound } from "next/navigation";
3 |
4 | import { Mdx } from "@/components/mdx/mdx-components";
https://nextjs.org/docs/messages/module-not-found
○ Compiling /_error ...
|
12513e3ce2333824305a1cfeef8761a3
|
{
"intermediate": 0.39478957653045654,
"beginner": 0.2868942618370056,
"expert": 0.31831616163253784
}
|
37,953
|
I want to design a board to light up 6 LEDs(like LED bar), based on Values of A 10K Ohm Potentiometer which I read from a power LED driver board, I have the code below :
#define F_CPU 16000000UL // 16 MHz clock
#include <avr/io.h>
#include <util/delay.h>
// Define potentiometer ADC channel (PA0 = ADC0)
#define potPin 0
// Define digital I/O pins for LEDs - changed to use PD1 to PD6
#define led1 PD1
#define led2 PD2
#define led3 PD3
#define led4 PD4
#define led5 PD5
#define led6 PD6
#define SAMPLES_TO_AVERAGE 10 // Number of samples to average for ADC
void adc_init()
{
// Initialize ADC
ADMUX = (1<<REFS0); // Select AVcc as reference voltage and ADC0 as input channel
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // Enable ADC and set prescaler to 128
}
uint16_t adc_read(uint8_t ch)
{
// Select ADC channel with safety mask and without changing the reference voltage selection
ADMUX = (ADMUX & 0xF0) | (ch & 0x0F);
// Start single conversion
ADCSRA |= (1<<ADSC);
// Wait until conversion is complete
while (ADCSRA & (1<<ADSC));
return ADC;
}
uint16_t adc_read_average(uint8_t ch)
{
uint32_t sum = 0;
for (int i = 0; i < SAMPLES_TO_AVERAGE; ++i) {
sum += adc_read(ch);
}
return (uint16_t)(sum / SAMPLES_TO_AVERAGE);
}
int main(void)
{
// Set up the LED pins as output - updated for PD1 to PD6
DDRD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5) | (1<<led6);
// Initialize ADC
adc_init();
while(1)
{
// Read the value from the potentiometer and average it
uint16_t potValue = adc_read_average(potPin);
// Map the potentiometer value from the given range (65 - 337) to (0 - 1023)
uint16_t mappedValue = (uint32_t)(potValue - 65) * 1023 / (337 - 65);
// Define thresholds based on the number of LEDs
uint16_t threshold1 = 170; // First threshold
uint16_t threshold2 = 341; // Second threshold
uint16_t threshold3 = 512; // Third threshold
uint16_t threshold4 = 683; // Fourth threshold
uint16_t threshold5 = 854; // Fifth threshold
// Turn off all LEDs to start with - updated for PD1 to PD6
PORTD &= ~((1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5) | (1<<led6));
// Determine which LEDs to light up based on the mappedValue - updated for PD1 to PD6
if (mappedValue >= threshold5) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5) | (1<<led6);
} else if (mappedValue >= threshold4) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5);
} else if (mappedValue >= threshold3) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4);
} else if (mappedValue >= threshold2) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3);
} else if (mappedValue >= threshold1) {
PORTD |= (1<<led1) | (1<<led2);
} else {
// Ensure led1 is always turned on regardless of the value
PORTD |= (1<<led1);
}
// Small delay to reduce flickering
_delay_ms(30);
}
}
when I turn the potentiometer to the maximum value, all the LEDs are turned on but when I reduce the value of the potentiometer all LEDs will be turned on and don't act as LED bars until I reach the minimum value of the potentiometer and then LED 1 will be turned on, it is important to consider I put a reset key in at mega, and when I push it , it reset the micro and every thing will work normally
|
82d23e5b377df5c3a0af63941b383493
|
{
"intermediate": 0.3584133982658386,
"beginner": 0.4452185332775116,
"expert": 0.1963680237531662
}
|
37,954
|
manually adding a node from existing cluster of infoscale 8 on linux 8.x if io fencing configured , with add VVR and GCO configuration : step by step and detail configuration with command
|
f4a21bf3962841b696fb45d915622f2f
|
{
"intermediate": 0.3444693982601166,
"beginner": 0.2570177912712097,
"expert": 0.3985127806663513
}
|
37,955
|
Optimize oracle select it is running too long
|
2935efd3a3ae569aabf8407e805b9f7b
|
{
"intermediate": 0.13670150935649872,
"beginner": 0.12910476326942444,
"expert": 0.734193742275238
}
|
37,956
|
After Every 3 line add wide space
|
6d1a21a0aeb89ad996d0490a7735d1b0
|
{
"intermediate": 0.3458824157714844,
"beginner": 0.31840088963508606,
"expert": 0.33571675419807434
}
|
37,957
|
I want to design a board to light up 6 LEDs(like LED bar), based on Values of A 10K Ohm Potentiometer which I read from a power LED driver board, I have the code below :
#define F_CPU 16000000UL // 16 MHz clock
#include <avr/io.h>
#include <util/delay.h>
// Define potentiometer ADC channel (PA0 = ADC0)
#define potPin 0
// Define digital I/O pins for LEDs - changed to use PD1 to PD6
#define led1 PD1
#define led2 PD2
#define led3 PD3
#define led4 PD4
#define led5 PD5
#define led6 PD6
#define SAMPLES_TO_AVERAGE 10 // Number of samples to average for ADC
void adc_init()
{
// Initialize ADC
ADMUX = (1<<REFS0); // Select AVcc as reference voltage and ADC0 as input channel
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // Enable ADC and set prescaler to 128
}
uint16_t adc_read(uint8_t ch)
{
// Select ADC channel with safety mask and without changing the reference voltage selection
ADMUX = (ADMUX & 0xF0) | (ch & 0x0F);
// Start single conversion
ADCSRA |= (1<<ADSC);
// Wait until conversion is complete
while (ADCSRA & (1<<ADSC));
return ADC;
}
uint16_t adc_read_average(uint8_t ch)
{
uint32_t sum = 0;
for (int i = 0; i < SAMPLES_TO_AVERAGE; ++i) {
sum += adc_read(ch);
}
return (uint16_t)(sum / SAMPLES_TO_AVERAGE);
}
int main(void)
{
// Set up the LED pins as output - updated for PD1 to PD6
DDRD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5) | (1<<led6);
// Initialize ADC
adc_init();
while(1)
{
// Read the value from the potentiometer and average it
uint16_t potValue = adc_read_average(potPin);
// Map the potentiometer value from the given range (65 - 337) to (0 - 1023)
uint16_t mappedValue = (uint32_t)(potValue - 65) * 1023 / (337 - 65);
// Define thresholds based on the number of LEDs
uint16_t threshold1 = 170; // First threshold
uint16_t threshold2 = 341; // Second threshold
uint16_t threshold3 = 512; // Third threshold
uint16_t threshold4 = 683; // Fourth threshold
uint16_t threshold5 = 854; // Fifth threshold
// Turn off all LEDs to start with - updated for PD1 to PD6
PORTD &= ~((1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5) | (1<<led6));
// Determine which LEDs to light up based on the mappedValue - updated for PD1 to PD6
if (mappedValue >= threshold5) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5) | (1<<led6);
} else if (mappedValue >= threshold4) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4) | (1<<led5);
} else if (mappedValue >= threshold3) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3) | (1<<led4);
} else if (mappedValue >= threshold2) {
PORTD |= (1<<led1) | (1<<led2) | (1<<led3);
} else if (mappedValue >= threshold1) {
PORTD |= (1<<led1) | (1<<led2);
} else {
// Ensure led1 is always turned on regardless of the value
PORTD |= (1<<led1);
}
// Small delay to reduce flickering
_delay_ms(30);
}
}
when I turn the potentiometer to the maximum value, all the LEDs are turned on but when I reduce the value of the potentiometer all LEDs will be turned on and don’t act as LED bars until I reach the minimum value of the potentiometer and then LED 1 will be turned on, it is important to consider I put a reset key in at mega, and when I push it , it reset the micro and every thing will work normally
|
f83e9a513f3be4572b725ef2ff050975
|
{
"intermediate": 0.4507240653038025,
"beginner": 0.3515320420265198,
"expert": 0.19774390757083893
}
|
37,958
|
How to handle having multiple clashes .Here is my code for handling single clashes by two element
import gymnasium as gym
import tensorflow as tf
import numpy as np
# Define constants
num_states = 4 # Number of features defining the state
num_actions = 6 # Number of possible resolution actions
upper_bound = -10 # Maximum value for resolution actions
lower_bound = 10 # Minimum value for resolution actions
# Define the Ornstein-Uhlenbeck noise process
class OUActionNoise:
def __init__(self, mean, std_deviation, theta=0.15, dt=1e-2, x_initial=None):
self.theta = theta
self.mean = mean
self.std_dev = std_deviation
self.dt = dt
self.x_initial = x_initial
self.reset()
def __call__(self):
x = (
self.x_prev
+ self.theta * (self.mean - self.x_prev) * self.dt
+ self.std_dev * np.sqrt(self.dt) * np.random.normal(size=self.mean.shape)
)
self.x_prev = x
return x
def reset(self):
if self.x_initial is not None:
self.x_prev = self.x_initial
else:
self.x_prev = np.zeros_like(self.mean)
# Define the Buffer class for experience replay
class Buffer:
def __init__(self, buffer_capacity=100000, batch_size=64):
self.buffer_capacity = buffer_capacity
self.batch_size = batch_size
self.buffer_counter = 0
self.state_buffer = np.zeros((self.buffer_capacity, num_states))
self.action_buffer = np.zeros((self.buffer_capacity, num_actions))
self.reward_buffer = np.zeros((self.buffer_capacity, 1))
self.next_state_buffer = np.zeros((self.buffer_capacity, num_states))
def record(self, obs_tuple):
print('obs_tuple================================',obs_tuple)
index = self.buffer_counter % self.buffer_capacity
print('====buffer_counter , buffer_capicity, index========',self.buffer_counter, self.buffer_capacity, index)
self.state_buffer[index] = obs_tuple[0]
self.action_buffer[index] = obs_tuple[1]
self.reward_buffer[index] = obs_tuple[2]
self.next_state_buffer[index] = obs_tuple[3]
self.buffer_counter += 1
@tf.function
def update(self, state_batch, action_batch, reward_batch, next_state_batch):
with tf.GradientTape() as tape:
target_actions = target_actor(next_state_batch, training=True)
y = reward_batch + gamma * target_critic(
[next_state_batch, target_actions], training=True
)
critic_value = critic_model([state_batch, action_batch], training=True)
critic_loss = tf.math.reduce_mean(tf.math.square(y - critic_value))
critic_grad = tape.gradient(critic_loss, critic_model.trainable_variables)
critic_optimizer.apply_gradients(
zip(critic_grad, critic_model.trainable_variables)
)
with tf.GradientTape() as tape:
actions = actor_model(state_batch, training=True)
critic_value = critic_model([state_batch, actions], training=True)
actor_loss = -tf.math.reduce_mean(critic_value)
actor_grad = tape.gradient(actor_loss, actor_model.trainable_variables)
actor_optimizer.apply_gradients(
zip(actor_grad, actor_model.trainable_variables)
)
def learn(self):
record_range = min(self.buffer_counter, self.buffer_capacity)
batch_indices = np.random.choice(record_range, self.batch_size)
state_batch = tf.convert_to_tensor(self.state_buffer[batch_indices])
action_batch = tf.convert_to_tensor(self.action_buffer[batch_indices])
reward_batch = tf.convert_to_tensor(self.reward_buffer[batch_indices])
reward_batch = tf.cast(reward_batch, dtype=tf.float32)
next_state_batch = tf.convert_to_tensor(self.next_state_buffer[batch_indices])
self.update(state_batch, action_batch, reward_batch, next_state_batch)
# Define the update_target function for updating target networks
@tf.function
def update_target(target_weights, weights, tau):
for (a, b) in zip(target_weights, weights):
a.assign(b * tau + a * (1 - tau))
# Define the actor and critic neural networks
def get_actor():
last_init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003)
inputs = tf.keras.layers.Input(shape=(num_states,))
out = tf.keras.layers.Dense(256, activation="relu")(inputs)
out = tf.keras.layers.Dense(256, activation="relu")(out)
outputs = tf.keras.layers.Dense(6, activation="tanh", kernel_initializer=last_init)(out)
outputs = outputs * upper_bound
model = tf.keras.Model(inputs, outputs)
return model
def get_critic():
state_input = tf.keras.layers.Input(shape=(num_states,))
state_out = tf.keras.layers.Dense(16, activation="relu")(state_input)
state_out = tf.keras.layers.Dense(32, activation="relu")(state_out)
action_input = tf.keras.layers.Input(shape=(num_actions,))
action_out = tf.keras.layers.Dense(32, activation="relu")(action_input)
concat = tf.keras.layers.Concatenate()([state_out, action_out])
out = tf.keras.layers.Dense(256, activation="relu")(concat)
out = tf.keras.layers.Dense(256, activation="relu")(out)
outputs = tf.keras.layers.Dense(1)(out)
model = tf.keras.Model([state_input, action_input], outputs)
return model
# Define the policy function
def policy(state, noise_object):
sampled_actions = tf.squeeze(actor_model(state))
noise = noise_object()
sampled_actions = sampled_actions.numpy() + noise
legal_action = np.clip(sampled_actions, lower_bound, upper_bound)
#return [np.squeeze(legal_action)]
return np.squeeze(legal_action)
# Define DDPG hyperparameters
std_dev = 0.2
ou_noise = OUActionNoise(mean=np.zeros(1), std_deviation=float(std_dev) * np.ones(1))
actor_model = get_actor()
critic_model = get_critic()
target_actor = get_actor()
target_critic = get_critic()
target_actor.set_weights(actor_model.get_weights())
target_critic.set_weights(critic_model.get_weights())
critic_lr = 0.002
actor_lr = 0.001
critic_optimizer = tf.keras.optimizers.Adam(critic_lr)
actor_optimizer = tf.keras.optimizers.Adam(actor_lr)
total_episodes = 100 # 100
gamma = 0.99
tau = 0.005
buffer = Buffer(50000, 64)
class ConstructionEnvironment(gym.Env):
def __init__(self, num_states, num_actions, lower_bound, upper_bound, max_episode_steps):
super(ConstructionEnvironment, self).__init__()
# Define action and observation spaces
self.action_space = gym.spaces.Box(low=lower_bound, high=upper_bound, shape=(num_actions,), dtype=np.float32)
self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(num_states,), dtype=np.float32)
# Initialize the state
self.state = np.zeros(num_states)
# Episode-related variables
self.episode_steps = 0
self.max_episode_steps = max_episode_steps
self.max_distance = np.sqrt(num_states) # Maximum Euclidean distance for normalization
def reset(self):
# Reset the state and episode steps
self.state = np.random.uniform(low=-1, high=1, size=self.observation_space.shape)
self.episode_steps = 0
return self.state
def step(self, action):
# Implement the actual step function based on your application
# Update the state, calculate reward, and check if the episode is done
self.episode_steps += 1
# Update state (simple example: add random noise to each state element)
self.state += np.random.normal(0, 0.1, size=self.observation_space.shape)
# Placeholder for reward calculation - maximize the negative Euclidean distance from the origin
reward = -np.linalg.norm(self.state) / self.max_distance
reward = self.calculate_reward(action) # Replace with your reward calculation
done = (self.episode_steps >= self.max_episode_steps) or (reward == 10)
return self.state, reward, done, {}
def calculate_reward(self,action):
reward = -0.5
# Example: Simple reward calculation based on the current state
# Replace this with your actual reward calculation logic
print('action=======inside Revit===========',action)
# data = np.array([-1.0, -1.0, 1.0, 1.0, 0.71324176, -1.0])
data = action
# Extract positions of element1 and element2
element1_position = data[:3]
element2_position = data[3:]
# Calculate Euclidean distance
euclidean_distance = np.linalg.norm(element1_position - element2_position)
# Print the result
print("Euclidean Distance:", euclidean_distance)
euclidian_d.append(euclidean_distance)
if 1.4 <= euclidean_distance <= 1.6:
reward = 10
# return -np.sum(np.square(self.state))
return reward
# Example of how to use the custom environment with specified parameters
num_states = 4
num_actions = 6
lower_bound = -1
upper_bound = 1
max_episode_steps = 200
env = ConstructionEnvironment(num_states=num_states, num_actions=num_actions, lower_bound=lower_bound, upper_bound=upper_bound, max_episode_steps=max_episode_steps)
env.max_episode_steps
# Train the DDPG model
reward_per_episode = []
def train_ddpg():
# env = ConstructionEnvironment()
for ep in range(total_episodes):
state = env.reset()
episodic_reward = 0
for i in range(env.max_episode_steps):
tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0)
action = policy(tf_state, ou_noise)
print('action==================&&&&&&&&&&&&====',type(action), action)
next_state, reward, done, _ = env.step(action)
# reward_data.append(reward)
print('next_state, reward, done, _====================',next_state, reward, done, _)
buffer.record((state, action, reward, next_state))
episodic_reward += reward
buffer.learn()
update_target(target_actor.variables, actor_model.variables, tau)
update_target(target_critic.variables, critic_model.variables, tau)
if done:
break
state = next_state
print("Episode * {} * Avg Reward ==> {}".format(ep, episodic_reward))
reward_per_episode.append(episodic_reward)
# Run the DDPG training
train_ddpg()
|
fd03f4316bbf56c09aa3149e11b8702e
|
{
"intermediate": 0.3070041835308075,
"beginner": 0.4329531788825989,
"expert": 0.26004260778427124
}
|
37,959
|
How to handle having multiple clashes .Here is my code for handling single clashes by two element
import gymnasium as gym
import tensorflow as tf
import numpy as np
# Define constants
num_states = 4 # Number of features defining the state
num_actions = 6 # Number of possible resolution actions
upper_bound = -10 # Maximum value for resolution actions
lower_bound = 10 # Minimum value for resolution actions
# Define the Ornstein-Uhlenbeck noise process
class OUActionNoise:
def init(self, mean, std_deviation, theta=0.15, dt=1e-2, x_initial=None):
self.theta = theta
self.mean = mean
self.std_dev = std_deviation
self.dt = dt
self.x_initial = x_initial
self.reset()
def call(self):
x = (
self.x_prev
+ self.theta * (self.mean - self.x_prev) * self.dt
+ self.std_dev * np.sqrt(self.dt) * np.random.normal(size=self.mean.shape)
)
self.x_prev = x
return x
def reset(self):
if self.x_initial is not None:
self.x_prev = self.x_initial
else:
self.x_prev = np.zeros_like(self.mean)
# Define the Buffer class for experience replay
class Buffer:
def init(self, buffer_capacity=100000, batch_size=64):
self.buffer_capacity = buffer_capacity
self.batch_size = batch_size
self.buffer_counter = 0
self.state_buffer = np.zeros((self.buffer_capacity, num_states))
self.action_buffer = np.zeros((self.buffer_capacity, num_actions))
self.reward_buffer = np.zeros((self.buffer_capacity, 1))
self.next_state_buffer = np.zeros((self.buffer_capacity, num_states))
def record(self, obs_tuple):
print(‘obs_tuple================================’,obs_tuple)
index = self.buffer_counter % self.buffer_capacity
print(‘====buffer_counter , buffer_capicity, index========’,self.buffer_counter, self.buffer_capacity, index)
self.state_buffer[index] = obs_tuple[0]
self.action_buffer[index] = obs_tuple[1]
self.reward_buffer[index] = obs_tuple[2]
self.next_state_buffer[index] = obs_tuple[3]
self.buffer_counter += 1
@tf.function
def update(self, state_batch, action_batch, reward_batch, next_state_batch):
with tf.GradientTape() as tape:
target_actions = target_actor(next_state_batch, training=True)
y = reward_batch + gamma * target_critic(
[next_state_batch, target_actions], training=True
)
critic_value = critic_model([state_batch, action_batch], training=True)
critic_loss = tf.math.reduce_mean(tf.math.square(y - critic_value))
critic_grad = tape.gradient(critic_loss, critic_model.trainable_variables)
critic_optimizer.apply_gradients(
zip(critic_grad, critic_model.trainable_variables)
)
with tf.GradientTape() as tape:
actions = actor_model(state_batch, training=True)
critic_value = critic_model([state_batch, actions], training=True)
actor_loss = -tf.math.reduce_mean(critic_value)
actor_grad = tape.gradient(actor_loss, actor_model.trainable_variables)
actor_optimizer.apply_gradients(
zip(actor_grad, actor_model.trainable_variables)
)
def learn(self):
record_range = min(self.buffer_counter, self.buffer_capacity)
batch_indices = np.random.choice(record_range, self.batch_size)
state_batch = tf.convert_to_tensor(self.state_buffer[batch_indices])
action_batch = tf.convert_to_tensor(self.action_buffer[batch_indices])
reward_batch = tf.convert_to_tensor(self.reward_buffer[batch_indices])
reward_batch = tf.cast(reward_batch, dtype=tf.float32)
next_state_batch = tf.convert_to_tensor(self.next_state_buffer[batch_indices])
self.update(state_batch, action_batch, reward_batch, next_state_batch)
# Define the update_target function for updating target networks
@tf.function
def update_target(target_weights, weights, tau):
for (a, b) in zip(target_weights, weights):
a.assign(b * tau + a * (1 - tau))
# Define the actor and critic neural networks
def get_actor():
last_init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003)
inputs = tf.keras.layers.Input(shape=(num_states,))
out = tf.keras.layers.Dense(256, activation=“relu”)(inputs)
out = tf.keras.layers.Dense(256, activation=“relu”)(out)
outputs = tf.keras.layers.Dense(6, activation=“tanh”, kernel_initializer=last_init)(out)
outputs = outputs * upper_bound
model = tf.keras.Model(inputs, outputs)
return model
def get_critic():
state_input = tf.keras.layers.Input(shape=(num_states,))
state_out = tf.keras.layers.Dense(16, activation=“relu”)(state_input)
state_out = tf.keras.layers.Dense(32, activation=“relu”)(state_out)
action_input = tf.keras.layers.Input(shape=(num_actions,))
action_out = tf.keras.layers.Dense(32, activation=“relu”)(action_input)
concat = tf.keras.layers.Concatenate()([state_out, action_out])
out = tf.keras.layers.Dense(256, activation=“relu”)(concat)
out = tf.keras.layers.Dense(256, activation=“relu”)(out)
outputs = tf.keras.layers.Dense(1)(out)
model = tf.keras.Model([state_input, action_input], outputs)
return model
# Define the policy function
def policy(state, noise_object):
sampled_actions = tf.squeeze(actor_model(state))
noise = noise_object()
sampled_actions = sampled_actions.numpy() + noise
legal_action = np.clip(sampled_actions, lower_bound, upper_bound)
#return [np.squeeze(legal_action)]
return np.squeeze(legal_action)
# Define DDPG hyperparameters
std_dev = 0.2
ou_noise = OUActionNoise(mean=np.zeros(1), std_deviation=float(std_dev) * np.ones(1))
actor_model = get_actor()
critic_model = get_critic()
target_actor = get_actor()
target_critic = get_critic()
target_actor.set_weights(actor_model.get_weights())
target_critic.set_weights(critic_model.get_weights())
critic_lr = 0.002
actor_lr = 0.001
critic_optimizer = tf.keras.optimizers.Adam(critic_lr)
actor_optimizer = tf.keras.optimizers.Adam(actor_lr)
total_episodes = 100 # 100
gamma = 0.99
tau = 0.005
buffer = Buffer(50000, 64)
class ConstructionEnvironment(gym.Env):
def init(self, num_states, num_actions, lower_bound, upper_bound, max_episode_steps):
super(ConstructionEnvironment, self).init()
# Define action and observation spaces
self.action_space = gym.spaces.Box(low=lower_bound, high=upper_bound, shape=(num_actions,), dtype=np.float32)
self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(num_states,), dtype=np.float32)
# Initialize the state
self.state = np.zeros(num_states)
# Episode-related variables
self.episode_steps = 0
self.max_episode_steps = max_episode_steps
self.max_distance = np.sqrt(num_states) # Maximum Euclidean distance for normalization
def reset(self):
# Reset the state and episode steps
self.state = np.random.uniform(low=-1, high=1, size=self.observation_space.shape)
self.episode_steps = 0
return self.state
def step(self, action):
# Implement the actual step function based on your application
# Update the state, calculate reward, and check if the episode is done
self.episode_steps += 1
# Update state (simple example: add random noise to each state element)
self.state += np.random.normal(0, 0.1, size=self.observation_space.shape)
# Placeholder for reward calculation - maximize the negative Euclidean distance from the origin
reward = -np.linalg.norm(self.state) / self.max_distance
reward = self.calculate_reward(action) # Replace with your reward calculation
done = (self.episode_steps >= self.max_episode_steps) or (reward == 10)
return self.state, reward, done, {}
def calculate_reward(self,action):
reward = -0.5
# Example: Simple reward calculation based on the current state
# Replace this with your actual reward calculation logic
print(‘action=======inside Revit===========’,action)
# data = np.array([-1.0, -1.0, 1.0, 1.0, 0.71324176, -1.0])
data = action
# Extract positions of element1 and element2
element1_position = data[:3]
element2_position = data[3:]
# Calculate Euclidean distance
euclidean_distance = np.linalg.norm(element1_position - element2_position)
# Print the result
print(“Euclidean Distance:”, euclidean_distance)
euclidian_d.append(euclidean_distance)
if 1.4 <= euclidean_distance <= 1.6:
reward = 10
# return -np.sum(np.square(self.state))
return reward
# Example of how to use the custom environment with specified parameters
num_states = 4
num_actions = 6
lower_bound = -1
upper_bound = 1
max_episode_steps = 200
env = ConstructionEnvironment(num_states=num_states, num_actions=num_actions, lower_bound=lower_bound, upper_bound=upper_bound, max_episode_steps=max_episode_steps)
env.max_episode_steps
# Train the DDPG model
reward_per_episode = []
def train_ddpg():
# env = ConstructionEnvironment()
for ep in range(total_episodes):
state = env.reset()
episodic_reward = 0
for i in range(env.max_episode_steps):
tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0)
action = policy(tf_state, ou_noise)
print(‘action==================&&&&&&&&&&&&====’,type(action), action)
next_state, reward, done, _ = env.step(action)
# reward_data.append(reward)
print(‘next_state, reward, done, _====================’,next_state, reward, done, _)
buffer.record((state, action, reward, next_state))
episodic_reward += reward
buffer.learn()
update_target(target_actor.variables, actor_model.variables, tau)
update_target(target_critic.variables, critic_model.variables, tau)
if done:
break
state = next_state
print(“Episode * {} * Avg Reward ==> {}”.format(ep, episodic_reward))
reward_per_episode.append(episodic_reward)
# Run the DDPG training
train_ddpg()
|
d71e0d06be4a65af0eb33b7fdfada3d5
|
{
"intermediate": 0.3776354193687439,
"beginner": 0.38709667325019836,
"expert": 0.23526789247989655
}
|
37,960
|
how to get value from js widjet to python code
|
5a2772bf61ff06ef74ab4c8542aeef62
|
{
"intermediate": 0.5721057057380676,
"beginner": 0.2032652199268341,
"expert": 0.22462907433509827
}
|
37,961
|
stage.set_background("spring")
clifford = codesters.Sprite("dog", -100, -75)
clifford.set_size(1.5)
spot = codesters.Sprite("puppy", 100, -75)
spot.set_size(.6)
my_dog = 7
my_puppy = 1
def age_converter(age):
dog_age = age * 7
return dog_age
my_dog_age = age_converter(age)
my_puppy_age = age_converter(my_puppy)
dog_display = codesters.Display(my_dog_age, -100, 50)
puppy_display = codesters.Display(my_puppy_age, 100, 50)
Debug the program so that the correct variable is passed to the function and my_dog_age is calculated!
|
a5d93e941ed46438d2d4d2b73588d65e
|
{
"intermediate": 0.40830424427986145,
"beginner": 0.3919453024864197,
"expert": 0.1997503936290741
}
|
37,962
|
private initChart() {
this.chart = echarts.init(this.$el as HTMLDivElement)
this.chart.setOption({
tooltip: {},
animationDurationUpdate: 1500,
animationEasingUpdate: 'quinticInOut',
series: [
{
type: 'graph',
layout: 'none',
symbolSize: 45,
roam: true,
label: {
show: true
},
edgeSymbol: ['circle', 'arrow'],
edgeSymbolSize: [4, 7],
edgeLabel: {
fontSize: 10,
},
itemStyle: {
color: '#fff',
borderColor: '#9DA2F2',
borderWidth: 1
},
hoverAnimation: true,
data: [
{
name: 'Node 1',
x: 300,
y: 300
},
{
name: 'Node 2',
x: 800,
y: 300
},
{
name: 'Node 3',
x: 550,
y: 100
},
{
name: 'Node 4',
x: 550,
y: 500
}
],
// links: [],
links: [
{
source: 'Node 1',
target: 'Node 3'
},
{
source: 'Node 2',
target: 'Node 3'
},
{
source: 'Node 2',
target: 'Node 4'
},
{
source: 'Node 1',
target: 'Node 4'
}
],
lineStyle: {
opacity: 0.9,
width: 2,
curveness: 0
}
}
]
})
}
@Prop() readonly groups: Group[]
export interface Group {
annotation: string
id: number
name: string
westsiteid: number
eastsiteid: number
}
vue 2 js как добавить данные с помощью пропса groups в initChart, чтобы отображалось westsiteid вместо source: 'Node 1',
|
fa3591cc8105fa442b09051caabea5f3
|
{
"intermediate": 0.4145806133747101,
"beginner": 0.4354476034641266,
"expert": 0.1499718278646469
}
|
37,963
|
why do I get "could not locate runnable browser" from the following code:
print("Confirm: " + object + "? (y/n)")
object2 = input("")
# if query is incorrect program ends
if(object2 == "y"):
# asking if user wants a recent search, then printing in terminal
print("Complete a recent scrape on " + object + "? (y/n)")
recentSearchScrape = input("")
if(recentSearchScrape == "y"):
recent_year = datetime.now().year - 1
query = object + " after:" + str(recent_year)
chrome_path="C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
webbrowser.register('chrome', None,webbrowser.BackgroundBrowser(chrome_path))
webbrowser.get('chrome').open_new_tab(url)
url = url + str(recent_year)
webbrowser.get(chrome_path).open(url)
# Fetch the URL data using requests.get(url),
# store it in a variable, query_result
query_result = requests.get(url)
soup = bs4.BeautifulSoup(query_result.text, "html.parser")
print(soup)
|
b3f92c4cf43d10ceebc28ede218cd00e
|
{
"intermediate": 0.2904778718948364,
"beginner": 0.6156272888183594,
"expert": 0.09389479458332062
}
|
37,964
|
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset
from collections import Counter
from tqdm import tqdm
# Expert LSTM Model
class LSTMExpert(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(LSTMExpert, self).__init__()
self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, x):
h, _ = self.lstm(x)
# Shape of h: [batch_size, sequence_length, hidden_size]
# No longer taking the last sequence output, transform for all time steps
h = h.reshape(-1, h.shape[2]) # Flatten to two dimensions: [batch_size * sequence_length, hidden_size]
return self.fc(h)
# Gating Network
class GatingNetwork(nn.Module):
def __init__(self, input_size, num_experts):
super(GatingNetwork, self).__init__()
self.fc = nn.Linear(input_size, num_experts)
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
if x.dim() > 2:
x = x.view(x.size(0), -1) # Flatten the tensor correctly
x = self.fc(x)
return self.softmax(x)
# Mixture of Experts Model
class MixtureOfExperts(nn.Module):
def __init__(self, input_size, hidden_size, output_size, num_experts):
super(MixtureOfExperts, self).__init__()
self.num_experts = num_experts
self.experts = nn.ModuleList([LSTMExpert(input_size, hidden_size, output_size) for _ in range(num_experts)])
self.gating_network = GatingNetwork(input_size, num_experts)
def forward(self, x):
# Flatten x for gating input: [batch_size * sequence_length, input_size]
gating_input = x.contiguous().view(-1, x.shape[-1])
# Get gating scores for each expert: [batch_size * sequence_length, num_experts, 1]
gating_scores = self.gating_network(gating_input).view(-1, self.num_experts, 1)
# Compute outputs from each expert
expert_outputs = [expert(x) for expert in self.experts] # List of [batch_size * sequence_length, vocab_size] tensors
# Stack along a new dimension for experts: [batch_size * sequence_length, vocab_size, num_experts]
expert_outputs = torch.stack(expert_outputs, dim=2)
# Calculate weighted sum of expert outputs: [batch_size * sequence_length, vocab_size]
mixed_output = torch.bmm(expert_outputs, gating_scores) # [batch_size * sequence_length, vocab_size, 1]
mixed_output = mixed_output.squeeze(-1) # Remove last singleton dimension
return mixed_output
class TextDataset(Dataset):
def __init__(self, path, seq_len):
self.seq_len = seq_len
with open(path, "r", encoding="utf-8") as f:
text = f.read()
words = text.split()
self.vocab, self.idx2token = self.build_vocab(words)
self.tokens = [self.vocab.get(w, 0) for w in words] # Default to 0 for unknown tokens
def build_vocab(self, words):
counts = Counter(words)
vocab = {word: i for i, (word, _) in enumerate(counts.most_common(), 1)}
vocab["<pad>"] = 0
idx2token = {i: word for word, i in vocab.items()}
return vocab, idx2token
def __len__(self):
return len(self.tokens) // self.seq_len
def __getitem__(self, idx):
chunk = self.tokens[idx * self.seq_len: (idx + 1) * self.seq_len]
x = chunk[:-1]
y = chunk[1:]
return torch.tensor(x), torch.tensor(y)
def collate_fn(batch):
inputs, targets = zip(*batch)
inputs = pad_sequence(inputs, batch_first=True, padding_value=0)
targets = pad_sequence(targets, batch_first=True, padding_value=0)
return inputs, targets
# Set the path to your text file and define sequence length
path_to_text = 'C:/Users/Dell-PC/Desktop/Projets/2-The-Beyond\Training-data/Summaries.txt' # replace with the path to your text file
seq_len = 128 # sequence length
# Create a dataset and data loader
dataset = TextDataset(path_to_text, seq_len)
data_loader = DataLoader(dataset, batch_size=96, shuffle=True, collate_fn=collate_fn)
def train_model_TXT(model, criterion, optimizer, num_epochs, data_loader):
model.train()
for epoch in range(num_epochs):
total_loss = 0
progress_bar = tqdm(data_loader, desc=f"Epoch {epoch+1}/{num_epochs}")
for inputs, targets in progress_bar:
optimizer.zero_grad()
# Forward pass
predictions = model(inputs)
# Flatten targets to be [batch_size * sequence_length]
targets = targets.view(-1)
# Flatten predictions to be [batch_size * sequence_length, num_classes]
predictions = predictions.view(-1, predictions.size(-1))
# Loss computation
loss = criterion(predictions, targets)
loss.backward()
optimizer.step()
total_loss += loss.item()
# Update the progress bar with the loss information
progress_bar.set_postfix(loss=loss.item())
average_loss = total_loss / len(data_loader)
print(f"Epoch {epoch+1}, Avg Loss: {average_loss:.4f}")
def generate_text(model, dataset, seed_text, num_generate, temperature=1.0):
model.eval() # Put the model in evaluation mode
# List to store the generated tokens
generated_tokens = []
# Initial sequence (prefix) to start the generation process
input_sequence = [dataset.vocab.get(word, dataset.vocab["<pad>"]) for word in seed_text.split()] # Convert to token IDs
current_sequence = torch.tensor(input_sequence, dtype=torch.long).unsqueeze(0)
# Generate num_generate tokens
for _ in range(num_generate):
# Forward pass through the model
with torch.no_grad():
output = model(current_sequence)
# Get probabilities, apply temperature scaling, and sample from the distribution
probabilities = F.softmax(output[-1] / temperature, dim=0).detach()
next_token_idx = torch.multinomial(probabilities, 1).item()
# Append token to the current sequence and to the generated tokens
generated_tokens.append(next_token_idx)
current_sequence = torch.cat((current_sequence, torch.tensor([[next_token_idx]])), 1)
# Convert tokens to words
generated_text = " ".join([dataset.idx2token.get(token, "<unk>") for token in generated_tokens]) # Use .get() to provide a default value for missing keys
return generated_text
# Integration of MoE with the rest of the code
vocab_size = len(dataset.vocab) # The size of the vocabulary
embedding_dim = 144 # Size of embeddings
hidden_size = 576 # Number of features in the hidden state of the LSTM
num_experts = 2 # Define the number of LSTM experts you want in your MoE model
# Instantiate the MixtureOfExperts model
mixture_of_experts_model = MixtureOfExperts(embedding_dim, hidden_size, vocab_size, num_experts)
# Wrap the experts and the embedding layer into a new combined model, replacing SingleLSTM_TXT
class MoEModel(nn.Module):
def __init__(self, embedding_dim, vocab_size, MoE):
super(MoEModel, self).__init__()
self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
self.MoE = MoE
def forward(self, x):
embedded = self.embedding(x)
output = self.MoE(embedded)
return output
# Instantiate the MoEModel with embeddings and mixture of experts
moe_model = MoEModel(embedding_dim, vocab_size, mixture_of_experts_model)
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
# Example usage with your model:
total_params = count_parameters(moe_model)
print(f"Total trainable parameters: {total_params}")
# Training parameters
num_epochs = 10
batch_size = 96
learning_rate = 1e-2
# Define Loss Function and Optimizer for MoE model
criterion = nn.CrossEntropyLoss() # Use CrossEntropyLoss for classification tasks
optimizer = torch.optim.Adam(moe_model.parameters(), lr=learning_rate)
# Replace references to single_lstm_txt_model with moe_model
# Train the model with the text data
train_model_TXT(moe_model, criterion, optimizer, num_epochs, data_loader)
# Start a loop for the interactive chat-like text generation
while True:
try:
# Get user input
seed_text = input("Enter seed text (type 'quit' to stop): ")
# Check if user wants to quit the interaction
if seed_text.lower() == "quit":
print("Exiting text generation chat.")
break
# User input is not empty and not “quit”, generate text
if seed_text.strip():
num_generate = 16 # Number of words to generate
temperature = 0.1 # Sampling temperature, higher will increase diversity
# Use the trained model to generate text
generated_text = generate_text(moe_model, dataset, seed_text, num_generate, temperature)
print("Generated Text:", generated_text)
else:
print("Seed text cannot be empty.")
except KeyboardInterrupt:
# Handle KeyboardInterrupt (Ctrl+C) to gracefully exit
print("\nExiting text generation chat.")
break
|
fbbe531aa7e055829bb72911e4f018bd
|
{
"intermediate": 0.29069021344184875,
"beginner": 0.41065967082977295,
"expert": 0.2986500859260559
}
|
37,965
|
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset
from collections import Counter
import json
# Expert LSTM Model
class LSTMExpert(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(LSTMExpert, self).__init__()
self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, x):
h, _ = self.lstm(x)
# Shape of h: [batch_size, sequence_length, hidden_size]
# No longer taking the last sequence output, transform for all time steps
h = h.reshape(-1, h.shape[2]) # Flatten to two dimensions: [batch_size * sequence_length, hidden_size]
return self.fc(h)
# Gating Network
class GatingNetwork(nn.Module):
def __init__(self, input_size, num_experts):
super(GatingNetwork, self).__init__()
self.fc = nn.Linear(input_size, num_experts)
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
if x.dim() > 2:
x = x.view(x.size(0), -1) # Flatten the tensor correctly
x = self.fc(x)
return self.softmax(x)
# Mixture of Experts Model
class MixtureOfExperts(nn.Module):
def __init__(self, input_size, hidden_size, output_size, num_experts):
super(MixtureOfExperts, self).__init__()
self.num_experts = num_experts
self.experts = nn.ModuleList([LSTMExpert(input_size, hidden_size, output_size) for _ in range(num_experts)])
self.gating_network = GatingNetwork(input_size, num_experts)
def forward(self, x):
# Flatten x for gating input: [batch_size * sequence_length, input_size]
gating_input = x.contiguous().view(-1, x.shape[-1])
# Get gating scores for each expert: [batch_size * sequence_length, num_experts, 1]
gating_scores = self.gating_network(gating_input).view(-1, self.num_experts, 1)
# Compute outputs from each expert
expert_outputs = [expert(x) for expert in self.experts] # List of [batch_size * sequence_length, vocab_size] tensors
# Stack along a new dimension for experts: [batch_size * sequence_length, vocab_size, num_experts]
expert_outputs = torch.stack(expert_outputs, dim=2)
# Calculate weighted sum of expert outputs: [batch_size * sequence_length, vocab_size]
mixed_output = torch.bmm(expert_outputs, gating_scores) # [batch_size * sequence_length, vocab_size, 1]
mixed_output = mixed_output.squeeze(-1) # Remove last singleton dimension
return mixed_output
class QAJsonlDataset(Dataset):
def __init__(self, path, seq_len):
self.seq_len = seq_len
self.pairs = self.load_data(path)
self.vocab, self.idx2token = self.build_vocab([word for pair in self.pairs for word in pair])
self.tokenized_pairs = [(self.tokenize(q), self.tokenize(a)) for q, a in self.pairs]
def load_data(self, path):
pairs = []
with open(path, "r", encoding="utf-8") as f:
for line in f:
data = json.loads(line.strip())
question, answer = data.get("question", ""), data.get("answer", "")
pairs.append((question.split(), answer.split()))
return pairs
def tokenize(self, words):
# Tokenize a sentence and pad if necessary
tokens = [self.vocab.get(w, self.vocab["<unk>"]) for w in words] # Use <unk> for unknown words
if len(tokens) < self.seq_len:
tokens += [self.vocab["<pad>"]] * (self.seq_len - len(tokens))
else:
tokens = tokens[:self.seq_len-1] + [self.vocab["<eos>"]] # Assuming you have an <eos> token in your vocab
return tokens
def build_vocab(self, words):
# You might include “<unk>”, “<pad>” etc. in the vocabulary beforehand
counts = Counter(words)
vocab = {word: i for i, (word, _) in enumerate(counts.most_common(), 2)}
vocab["<unk>"] = 0
vocab["<pad>"] = 1
idx2token = {i: word for word, i in vocab.items()}
return vocab, idx2token
def __len__(self):
return len(self.tokenized_pairs)
def __getitem__(self, idx):
tokenized_question, tokenized_answer = self.tokenized_pairs[idx]
return torch.tensor(tokenized_question, dtype=torch.long), torch.tensor(tokenized_answer, dtype=torch.long)
def collate_fn(batch):
questions, answers = zip(*batch)
questions = pad_sequence(questions, batch_first=True, padding_value=0)
answers = pad_sequence(answers, batch_first=True, padding_value=0)
return questions, answers
# Set the path to your text file and define sequence length
path_to_text = 'GSM2K.jsonl' # replace with the path to your text file
seq_len = 32 # sequence length
# Create a dataset and data loader
dataset = QAJsonlDataset(path_to_text, seq_len)
data_loader = DataLoader(dataset, batch_size=32, shuffle=True, collate_fn=collate_fn)
def train_model_TXT(model, criterion, optimizer, num_epochs, data_loader):
model.train()
for epoch in range(num_epochs):
total_loss = 0
for i, (inputs, targets) in enumerate(data_loader):
optimizer.zero_grad()
# Forward pass
predictions = model(inputs)
# Flatten targets to be [batch_size * sequence_length]
targets = targets.view(-1)
# Flatten predictions to be [batch_size * sequence_length, num_classes]
predictions = predictions.view(-1, predictions.size(-1))
# Loss computation
loss = criterion(predictions, targets)
loss.backward()
optimizer.step()
total_loss += loss.item()
average_loss = total_loss / len(data_loader.dataset)
print(f"Epoch {epoch+1}, Loss: {average_loss}")
def generate_text(model, dataset, seed_text, num_generate, temperature=1.0):
model.eval() # Put the model in evaluation mode
# List to store the generated tokens
generated_tokens = []
# Initial sequence (prefix) to start the generation process
input_sequence = [dataset.vocab.get(word, dataset.vocab["<pad>"]) for word in seed_text.split()] # Convert to token IDs
current_sequence = torch.tensor(input_sequence, dtype=torch.long).unsqueeze(0)
# Generate num_generate tokens
for _ in range(num_generate):
# Forward pass through the model
with torch.no_grad():
output = model(current_sequence)
# Get probabilities, apply temperature scaling, and sample from the distribution
probabilities = F.softmax(output[-1] / temperature, dim=0).detach()
next_token_idx = torch.multinomial(probabilities, 1).item()
# Append token to the current sequence and to the generated tokens
generated_tokens.append(next_token_idx)
current_sequence = torch.cat((current_sequence, torch.tensor([[next_token_idx]])), 1)
# Convert tokens to words
generated_text = " ".join([dataset.idx2token.get(token, "<unk>") for token in generated_tokens]) # Use .get() to provide a default value for missing keys
return generated_text
# Integration of MoE with the rest of the code
vocab_size = len(dataset.vocab) # The size of the vocabulary
embedding_dim = 128 # Size of embeddings
hidden_size = 256 # Number of features in the hidden state of the LSTM
num_experts = 2 # Define the number of LSTM experts you want in your MoE model
# Instantiate the MixtureOfExperts model
mixture_of_experts_model = MixtureOfExperts(embedding_dim, hidden_size, vocab_size, num_experts)
# Wrap the experts and the embedding layer into a new combined model, replacing SingleLSTM_TXT
class MoEModel(nn.Module):
def __init__(self, embedding_dim, vocab_size, MoE):
super(MoEModel, self).__init__()
self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
self.MoE = MoE
def forward(self, x):
embedded = self.embedding(x)
output = self.MoE(embedded)
return output
# Instantiate the MoEModel with embeddings and mixture of experts
moe_model = MoEModel(embedding_dim, vocab_size, mixture_of_experts_model)
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
# Example usage with your model:
total_params = count_parameters(moe_model)
print(f"Total trainable parameters: {total_params}")
# Training parameters
num_epochs = 2
batch_size = 32
learning_rate = 1e-3
# Define Loss Function and Optimizer for MoE model
criterion = nn.CrossEntropyLoss() # Use CrossEntropyLoss for classification tasks
optimizer = torch.optim.Adam(moe_model.parameters(), lr=learning_rate)
# Replace references to single_lstm_txt_model with moe_model
# Train the model with the text data
train_model_TXT(moe_model, criterion, optimizer, num_epochs, data_loader)
# Start a loop for the interactive chat-like text generation
while True:
try:
# Get user input
seed_text = input("Enter seed text (type 'quit' to stop): ")
# Check if user wants to quit the interaction
if seed_text.lower() == "quit":
print("Exiting text generation chat.")
break
# User input is not empty and not “quit”, generate text
if seed_text.strip():
num_generate = 16 # Number of words to generate
temperature = 0.5 # Sampling temperature, higher will increase diversity
# Use the trained model to generate text
generated_text = generate_text(moe_model, dataset, seed_text, num_generate, temperature)
print("Generated Text:", generated_text)
else:
print("Seed text cannot be empty.")
except KeyboardInterrupt:
# Handle KeyboardInterrupt (Ctrl+C) to gracefully exit
print("\nExiting text generation chat.")
break
|
b88d95808f62f043e9efe0beb841b963
|
{
"intermediate": 0.31441810727119446,
"beginner": 0.41545039415359497,
"expert": 0.27013152837753296
}
|
37,966
|
ez
|
ed580073ba321632da10c4886a04b230
|
{
"intermediate": 0.33496376872062683,
"beginner": 0.2928656041622162,
"expert": 0.3721705973148346
}
|
37,967
|
how do I modify this code so that I can print everything inside the <h3> of a page?
|
249cd88f550aa42d5cef4437119711c7
|
{
"intermediate": 0.4539750814437866,
"beginner": 0.29025033116340637,
"expert": 0.25577446818351746
}
|
37,968
|
Как в Python разрезать кривую Безье посередине и правую часть кривой Безье сдвинуть на пять единиц вверх
|
b57417471c6cb897327440534168d984
|
{
"intermediate": 0.3859216868877411,
"beginner": 0.25138455629348755,
"expert": 0.3626936972141266
}
|
37,969
|
Используя этот код n_1 = random.randint(20, 30)
x_start = random.randint(-9, -6)
x_end = random.randint(2, 17)
x_arr = sorted(np.random.uniform(x_start, x_end, n_1))
y_arr = np.random.uniform(-15, 15, n_1)
nodes1 = np.asfortranarray([[x_start, *x_arr, x_end + 1], [1.0, *y_arr, 1.0]])
curve1 = bezier.Curve(nodes1, degree=n_1 + 1)
t_values = np.linspace(0.0, 1, 1000)
points = curve1.evaluate_multi(t_values), в Python была построена кривая Безье. Сейчас надо разделить эту кривую Безье на две части. Затем на одном графике надо построить левую часть кривой Безье и правую часть кривой Безье сдвинутую на пять единиц вверх.
|
76efeed34c626cb5da72af01eb8076ef
|
{
"intermediate": 0.32898464798927307,
"beginner": 0.26426249742507935,
"expert": 0.4067527949810028
}
|
37,970
|
Implement the following method that, given two stacks and an integer, moves entries between the two stacks so that the length of the first stack is equal to the given integer. Note that, as the ensures clause states, rev(leftStack) * rightStack must not be changed by the method.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
* Shifts entries between {@code leftStack} and {@code rightStack}, keeping
* reverse of the former concatenated with the latter fixed, and resulting
* in length of the former equal to {@code newLeftLength}.
*
* @param <T>
* type of {@code Stack} entries
* @param leftStack
* the left {@code Stack}
* @param rightStack
* the right {@code Stack}
* @param newLeftLength
* desired new length of {@code leftStack}
* @updates leftStack, rightStack
* @requires <pre>
* 0 <= newLeftLength and
* newLeftLength <= |leftStack| + |rightStack|
* </pre>
* @ensures <pre>
* rev(leftStack) * rightStack = rev(#leftStack) * #rightStack and
* |leftStack| = newLeftLength}
* </pre>
*/
private static <T> void setLengthOfLeftStack(Stack<T> leftStack,
Stack<T> rightStack, int newLeftLength) {...}
Note that setLengthOfLeftStack is a static, generic method: it is parameterized by the type T of the entries in the stacks. You can use the type T wherever you need to declare a variable that refers to an object of type T.
|
07b3a3c23af0cf057880dba1c6cca94f
|
{
"intermediate": 0.41426071524620056,
"beginner": 0.2749975621700287,
"expert": 0.31074172258377075
}
|
37,971
|
I have a module in layout xml file:
<TextView
android:id="@+id/Coins"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_margin="200px"
android:textSize="20dp"
android:textStyle="bold|italic"
android:textAlignment="center"
android:text="teszt"
android:shadowColor="@color/black"
android:shadowRadius="100"
/>
In the java part, I have this: mTextView.setText("You have "+String.valueOf(amount)+" coins. Watch Rewarded Ads to earn more!");
I get this warning: String literal in setText can not be translated. Use Android resources instead
What is this warning about? How can I fix it?
|
eb0603b3d4f5632fd48b11124617cf42
|
{
"intermediate": 0.4092142879962921,
"beginner": 0.30838489532470703,
"expert": 0.28240081667900085
}
|
37,972
|
Implement the following method that, given two stacks and an integer, moves entries between the two stacks so that the length of the first stack is equal to the given integer. Note that, as the ensures clause states, rev(leftStack) * rightStack must not be changed by the method.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
* Shifts entries between {@code leftStack} and {@code rightStack}, keeping
* reverse of the former concatenated with the latter fixed, and resulting
* in length of the former equal to {@code newLeftLength}.
*
* @param <T>
* type of {@code Stack} entries
* @param leftStack
* the left {@code Stack}
* @param rightStack
* the right {@code Stack}
* @param newLeftLength
* desired new length of {@code leftStack}
* @updates leftStack, rightStack
* @requires <pre>
* 0 <= newLeftLength and
* newLeftLength <= |leftStack| + |rightStack|
* </pre>
* @ensures <pre>
* rev(leftStack) * rightStack = rev(#leftStack) * #rightStack and
* |leftStack| = newLeftLength}
* </pre>
*/
private static <T> void setLengthOfLeftStack(Stack<T> leftStack,
Stack<T> rightStack, int newLeftLength) {...}
Note that setLengthOfLeftStack is a static, generic method: it is parameterized by the type T of the entries in the stacks. You can use the type T wherever you need to declare a variable that refers to an object of type T.
|
223e990e9372663691e57a4f834b2400
|
{
"intermediate": 0.41426071524620056,
"beginner": 0.2749975621700287,
"expert": 0.31074172258377075
}
|
37,973
|
Implement the following method that, given a queue and an entry of type T, searches for the given entry in the given queue and, if it finds it, moves that entry to the front of the queue.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* Finds {@code x} in {@code q} and, if such exists, moves it to the front
* of {@code q}.
*
* @param <T>
* type of {@code Queue} entries
* @param q
* the {@code Queue} to be searched
* @param x
* the entry to be searched for
* @updates q
* @ensures <pre>
* perms(q, #q) and
* if <x> is substring of q
* then <x> is prefix of q
* </pre>
*/
private static <T> void moveToFront(Queue<T> q, T x) {...}
Note that moveToFront is a static, generic method: it is parameterized by the type T of the entries in the queue. You can use the type T wherever you need to declare a variable that refers to an object of type T.
|
f4ca7312d2e5b64aabebc088ca1c9577
|
{
"intermediate": 0.3082960546016693,
"beginner": 0.3396795392036438,
"expert": 0.3520244359970093
}
|
37,974
|
Implement the following method that, given a queue of Map.Pair<K, V> and a key of type K, searches for a pair with the given key in the given queue and, if it finds it, moves that pair to the front of the queue.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
* Finds pair with first component {@code key} and, if such exists, moves it
* to the front of {@code q}.
*
* @param <K>
* type of {@code Pair} key
* @param <V>
* type of {@code Pair} value
* @param q
* the {@code Queue} to be searched
* @param key
* the key to be searched for
* @updates q
* @ensures <pre>
* perms(q, #q) and
* if there exists value: V (<(key, value)> is substring of q)
* then there exists value: V (<(key, value)> is prefix of q)
* </pre>
*/
private static <K, V> void moveToFront(Queue<Pair<K, V>> q, K key) {...}
Note that moveToFront is a static, generic method: it is parameterized by the types K and V of the Map.Pair<K, V> entries in the queue. You can use the types K, V, and Pair<K, V> wherever you need to declare a variable that refers to an object of any of these types.
Pay attention to the contract. There is no requires clause. If you have trouble reading and understanding the ensures clause, be sure to ask for help.
If you need to construct a Pair object in your code (it should not be necessary in moveToFront, but you will need it in the lab), just use the only available implementation of the Map.Pair interface called MapSecondary.SimplePair<K, V>. Inside the Map2 class, you will be able to declare and initialize a Pair variable with a statement like this:
Pair<K, V> p = new SimplePair<>(key, value);
where key and value are some variables of type K and V, respectively.
|
fc7367d81e1fa7adb528abd27aee031c
|
{
"intermediate": 0.35113096237182617,
"beginner": 0.34660422801971436,
"expert": 0.3022647798061371
}
|
37,975
|
Suppose you are implementing the following class representing 7-digit phone numbers in the form "XXX-XXXX" for a phone in the immediate OSU area. That is, you may assume the length of the PhoneNumber value is 8 and that each "X" is a digit '0'-'9'.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* Simple class representing a 7-digit phone number in the form "XXX-XXXX"
* for a phone in the immediate OSU area.
*/
public class PhoneNumber {
/**
* The phone number representation.
*/
private String rep;
/**
* Constructor. {@code pNum} must be in the form "XXX-XXXX" where each
* "X" is a digit '0'-'9'.
*/
public PhoneNumber(String pNum) {
this.rep = pNum;
}
...
@Override
public int hashCode() {
// TODO - fill in body
}
...
}
Write the code to implement the hashCode instance method. You can use the Character.digit(char ch, int radix) method to convert a "digit" character ch into the corresponding numeric value in the specified radix.
|
5cb7671383dccecc80f82a5f0c2aedf8
|
{
"intermediate": 0.42621326446533203,
"beginner": 0.39899909496307373,
"expert": 0.17478761076927185
}
|
37,976
|
Write a recursive body for the following static, generic method that computes and returns the size of a given BinaryTree<T>. You can use any of the BinaryTree methods except for the iterator and the size kernel method. Note that the BinaryTree must be restored, i.e., its outgoing value must be the same as its incoming value.
1
2
3
4
5
6
7
8
9
10
11
/**
* Returns the size of the given {@code BinaryTree<T>}.
*
* @param <T>
* the type of the {@code BinaryTree} node labels
* @param t
* the {@code BinaryTree} whose size to return
* @return the size of the given {@code BinaryTree}
* @ensures size = |t|
*/
public static <T> int size(BinaryTree<T> t) {...}
Provide a second implementation of the size method above but this time make it an iterative (non-recursive) solution. You cannot use the size kernel method in your solution.
|
7b8ca2d8187e14bc178a8203b8278bdf
|
{
"intermediate": 0.3882700204849243,
"beginner": 0.3419654667377472,
"expert": 0.2697644829750061
}
|
37,977
|
Write a recursive body for the following static, generic method that returns a String representation of a given BinaryTree<T>. You cannot use the BinaryTree toString method in your solution. Note that the BinaryTree must be restored, i.e., its outgoing value must be the same as its incoming value.
1
2
3
4
5
6
7
8
9
10
11
12
/**
* Returns the {@code String} prefix representation of the given
* {@code BinaryTree<T>}.
*
* @param <T>
* the type of the {@code BinaryTree} node labels
* @param t
* the {@code BinaryTree} to convert to a {@code String}
* @return the prefix representation of {@code t}
* @ensures treeToString = [the String prefix representation of t]
*/
public static <T> String treeToString(BinaryTree<T> t) {...}
The prefix representation of the empty tree is "()", and the prefix representation of a non-empty BinaryTree<T> is the string concatenation of the root, followed by '(', then by the prefix representation of the left subtree, the prefix representation of the right subtree, and finally ')'. Here are five examples of prefix representations of some BinaryTree<Character>s. See if you can figure out and draw the binary trees being described.
()
a(()())
a(b(()())c(()()))
a(()b(()()))
a(()b(c(()())()))
Write a recursive body for the following static method that copies and returns a given BinaryTree<Integer>. Note that the given BinaryTree must be restored, i.e., its outgoing value must be the same as its incoming value.
1
2
3
4
5
6
7
8
9
/**
* Returns a copy of the the given {@code BinaryTree}.
*
* @param t
* the {@code BinaryTree} to copy
* @return a copy of the given {@code BinaryTree}
* @ensures copy = t
*/
public static BinaryTree<Integer> copy(BinaryTree<Integer> t) {...}
|
a4b5d351816a59ff1c249a1c5ed3dd89
|
{
"intermediate": 0.33609747886657715,
"beginner": 0.33822858333587646,
"expert": 0.325673907995224
}
|
37,978
|
1. Implement the static method insertInOrder declared below that inserts an entry, x, into a sorted queue, q, in the appropriate position to keep the queue sorted. Use the int order.compare(T, T) method to compare entries and find the correct insertion point.
/**
* Inserts the given {@code T} in the {@code Queue<T>} sorted according to
* the given {@code Comparator<T>} and maintains the {@code Queue<T>}
* sorted.
*
* @param <T>
* type of {@code Queue} entries
* @param q
* the {@code Queue} to insert into
* @param x
* the {@code T} to insert
* @param order
* the {@code Comparator} defining the order for {@code T}
* @updates q
* @requires <pre>
* IS_TOTAL_PREORDER([relation computed by order.compare method]) and
* IS_SORTED(q, [relation computed by order.compare method])
* </pre>
* @ensures <pre>
* perms(q, #q * <x>) and
* IS_SORTED(q, [relation computed by order.compare method])
* </pre>
*/
private static <T> void insertInOrder(Queue<T> q, T x, Comparator<T> order) {...}
2. Implement the instance method sort declared below that sorts a Queue<T> (this) using the "insertion sort" algorithm according to the given order. This algorithm repeatedly calls dequeue until this is empty, placing the entries into a temporary queue with insertInOrder, and then finally transferring this temporary object into this.
/**
* Sorts {@code this} according to the ordering provided by the
* {@code compare} method from {@code order}.
*
* @param order
* ordering by which to sort
* @updates this
* @requires IS_TOTAL_PREORDER([relation computed by order.compare method])
* @ensures <pre>
* perms(this, #this) and
* IS_SORTED(this, [relation computed by order.compare method])
* </pre>
*/
public void sort(Comparator<T> order) {...}
3. For the trace in this question, please assume the presence in the same class of the following static nested class:
/**
* Integer greater-than-or-equal-to Comparator. This effect is achieved by
* reversing the natural ordering provided by interface Comparable's
* compareTo, which Integer implements as less-than-or-equal-to.
*/
private static class IntegerGE implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
}
|
dc5b07a94cb5c0e612443cb28ed43752
|
{
"intermediate": 0.3032843768596649,
"beginner": 0.26345789432525635,
"expert": 0.43325769901275635
}
|
37,979
|
Implement the instance method sort declared below that sorts a Queue<T> (this) using the "insertion sort" algorithm according to the given order. This algorithm repeatedly calls dequeue until this is empty, placing the entries into a temporary queue with insertInOrder, and then finally transferring this temporary object into this.
/**
* Sorts {@code this} according to the ordering provided by the
* {@code compare} method from {@code order}.
*
* @param order
* ordering by which to sort
* @updates this
* @requires IS_TOTAL_PREORDER([relation computed by order.compare method])
* @ensures <pre>
* perms(this, #this) and
* IS_SORTED(this, [relation computed by order.compare method])
* </pre>
*/
public void sort(Comparator<T> order) {...}
|
3289db45cbce981a9729ee665a099b92
|
{
"intermediate": 0.35229700803756714,
"beginner": 0.26546454429626465,
"expert": 0.3822384178638458
}
|
37,980
|
Given the following heap, where the items are integers and the heap is ordered according to the <= relation:
2
/ \
5 6
/ \ /
8 5 7
Use ASCII characters to visualize the five heaps with text and spaces resulting from removing each of the first five items in the ordering using the algorithm discussed in class (see slides 26-32 in Heaps and Heapsort).
Write the body of the following static method, which returns true if and only if the given BinaryTree<Integer>, t, satisfies the heap ordering property according to the <= relation. (Note that this says nothing about the shape of the tree, i.e., it should work whether or not t is a complete binary tree, and should not check whether it is.)
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* Checks if the given {@code BinaryTree<Integer>} satisfies the heap
* ordering property according to the <= relation.
*
* @param t
* the binary tree
* @return true if the given tree satisfies the heap ordering property;
* false otherwise
* @ensures <pre>
* satisfiesHeapOrdering = [t satisfies the heap ordering property]
* </pre>
*/
private static boolean satisfiesHeapOrdering(BinaryTree<Integer> t) {...}
Draw and complete the commutativity diagram on slides 18-23 in More About Heaps.
|
db3969e387230bcdd83d662bb8191bc4
|
{
"intermediate": 0.2975340783596039,
"beginner": 0.31110483407974243,
"expert": 0.3913610577583313
}
|
37,981
|
1. Carefully review the Queue2 implementation of Queue kernel represented as a singly-linked list of Nodes. In particular, look at the representation fields (and the convention and correspondence) and the code in createNewRep and the constructor, and draw a picture (in the style used in the Linked Data Structures slides) of the Queue2 representation right after the constructor is executed.
2. Carefully review the Stack2 skeleton of Stack kernel represented as a singly-linked list of Nodes. In particular, look at the representation fields and the convention and correspondence, and draw a picture (in the style used in the Linked Data Structures slides) of the representation a Stack2 object should have right after the constructor is executed.
3. Complete the implementation of the Stack kernel represented as a singly-linked list of Nodes in the skeleton provided, Stack2. You need to write bodies for the private method createNewRep and for the kernel methods push, pop, and length.
Note that although the Stack2 implementation is similar to the Queue2 implementation, there are two significant differences: (1) the Queue2 representation has three fields (instance variables): preFront, rear, and length, while Stack2 only has two fields: top and length; (2) the singly-linked list representing Queue2 has one extra "smart" node at the front of the list, while the singly-linked list representing Stack2 does not include this extra node.
4. Develop a complete test plan for the Stack2 constructor and kernel methods you implemented and enter them in StackTest.
package components.queue;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* {@code Queue} represented as a singly linked list, done "bare-handed", with
* implementations of primary methods.
*
* <p>
* Execution-time performance of all methods implemented in this class is O(1).
*
* @param <T>
* type of {@code Queue} entries
* @convention <pre>
* $this.length >= 0 and
* [$this.preFront is not null] and
* [$this.rear is not null] and
* [$this.preFront points to the first node of a singly linked list
* containing $this.length + 1 nodes] and
* [$this.rear points to the last node in that singly linked list] and
* [$this.rear.next is null]
* </pre>
* @correspondence <pre>
* this = [data in nodes starting at $this.preFront.next and
* running through $this.rear]
* </pre>
*/
public class Queue2<T> extends QueueSecondary<T> {
/*
* Private members --------------------------------------------------------
*/
/**
* Node class for singly linked list nodes.
*/
private final class Node {
/**
* Data in node.
*/
private T data;
/**
* Next node in singly linked list, or null.
*/
private Node next;
}
/**
* "Smart node" before front node of singly linked list.
*/
private Node preFront;
/**
* Rear node of singly linked list.
*/
private Node rear;
/**
* One less than number of nodes in singly linked list, i.e., length =
* |this|.
*/
private int length;
/**
* Creator of initial representation.
*/
private void createNewRep() {
this.preFront = new Node();
this.preFront.next = null;
this.rear = this.preFront;
this.length = 0;
}
/*
* Constructors -----------------------------------------------------------
*/
/**
* Np-argument constructor.
*/
public Queue2() {
this.createNewRep();
}
/*
* Standard methods removed to reduce clutter...
*/
/*
* Kernel methods ---------------------------------------------------------
*/
@Override
public final void enqueue(T x) {
assert x != null : "Violation of: x is not null";
Node p = new Node();
Node q = this.rear;
p.data = x;
p.next = null;
q.next = p;
this.rear = p;
this.length++;
}
@Override
public final T dequeue() {
assert this.length() > 0 : "Violation of: this /= <>";
Node p = this.preFront;
Node q = p.next;
T result = q.data;
this.preFront = q;
this.length--;
return result;
}
@Override
public final int length() {
return this.length;
}
/*
* Iterator code removed to reduce clutter...
*/
/*
* Other methods (overridden for performance reasons) ---------------------
*/
@Override
public final T front() {
assert this.length() > 0 : "Violation of: this /= <>";
return this.preFront.next.data;
}
@Override
public final T replaceFront(T x) {
assert this.length() > 0 : "Violation of: this /= <>";
T front = this.preFront.next.data;
this.preFront.next.data = x;
return front;
}
}
import java.util.Iterator;
import java.util.NoSuchElementException;
import components.stack.Stack;
import components.stack.StackSecondary;
/**
* {@code Stack} represented as a singly linked list, done "bare-handed", with
* implementations of primary methods.
*
* <p>
* Execution-time performance of all methods implemented in this class is O(1).
*
* @param <T>
* type of Stack entries
* @convention <pre>
* $this.length >= 0 and
* if $this.length == 0 then
* [$this.top is null]
* else
* [$this.top is not null] and
* [$this.top points to the first node of a singly linked list
* containing $this.length nodes] and
* [next in the last node of that list is null]
* </pre>
* @correspondence this = [data in $this.length nodes starting at $this.top]
*/
public class Stack2<T> extends StackSecondary<T> {
/*
* Private members --------------------------------------------------------
*/
/**
* Node class for singly linked list nodes.
*/
private final class Node {
/**
* Data in node.
*/
private T data;
/**
* Next node in singly linked list, or null.
*/
private Node next;
}
/**
* Top node of singly linked list.
*/
private Node top;
/**
* Number of nodes in singly linked list, i.e., length = |this|.
*/
private int length;
/**
* Creator of initial representation.
*/
private void createNewRep() {
// TODO - fill in body
}
/*
* Constructors -----------------------------------------------------------
*/
/**
* No-argument constructor.
*/
public Stack2() {
this.createNewRep();
}
/*
* Standard methods removed to reduce clutter...
*/
/*
* Kernel methods ---------------------------------------------------------
*/
@Override
public final void push(T x) {
assert x != null : "Violation of: x is not null";
// TODO - fill in body
}
@Override
public final T pop() {
assert this.length() > 0 : "Violation of: this /= <>";
// TODO - fill in body
}
@Override
public final int length() {
// TODO - fill in body
}
/*
* Iterator code removed to reduce clutter...
*/
}
import components.stack.Stack;
/**
* JUnit test fixture for {@code Stack<String>}'s constructor and kernel
* methods.
*
* @author Put your name here
*
*/
public abstract class StackTest {
/**
* Invokes the appropriate {@code Stack} constructor for the implementation
* under test and returns the result.
*
* @return the new stack
* @ensures constructorTest = <>
*/
protected abstract Stack<String> constructorTest();
/**
* Invokes the appropriate {@code Stack} constructor for the reference
* implementation and returns the result.
*
* @return the new stack
* @ensures constructorRef = <>
*/
protected abstract Stack<String> constructorRef();
/**
*
* Creates and returns a {@code Stack<String>} of the implementation under
* test type with the given entries.
*
* @param args
* the entries for the stack
* @return the constructed stack
* @ensures createFromArgsTest = [entries in args]
*/
private Stack<String> createFromArgsTest(String... args) {
Stack<String> stack = this.constructorTest();
for (String s : args) {
stack.push(s);
}
stack.flip();
return stack;
}
/**
*
* Creates and returns a {@code Stack<String>} of the reference
* implementation type with the given entries.
*
* @param args
* the entries for the stack
* @return the constructed stack
* @ensures createFromArgsRef = [entries in args]
*/
private Stack<String> createFromArgsRef(String... args) {
Stack<String> stack = this.constructorRef();
for (String s : args) {
stack.push(s);
}
stack.flip();
return stack;
}
// TODO - add test cases for constructor, push, pop, and length
}
|
2d81bed9d225def9c33cd7d16b34cebe
|
{
"intermediate": 0.38987037539482117,
"beginner": 0.3760035037994385,
"expert": 0.23412610590457916
}
|
37,982
|
1. Carefully review the Queue2 implementation of Queue kernel represented as a singly-linked list of Nodes. In particular, look at the representation fields (and the convention and correspondence) and the code in createNewRep and the constructor, and draw a picture (in the style used in the Linked Data Structures slides) of the Queue2 representation right after the constructor is executed. 2. Carefully review the Stack2 skeleton of Stack kernel represented as a singly-linked list of Nodes. In particular, look at the representation fields and the convention and correspondence, and draw a picture (in the style used in the Linked Data Structures slides) of the representation a Stack2 object should have right after the constructor is executed. 3. Complete the implementation of the Stack kernel represented as a singly-linked list of Nodes in the skeleton provided, Stack2. You need to write bodies for the private method createNewRep and for the kernel methods push, pop, and length. Note that although the Stack2 implementation is similar to the Queue2 implementation, there are two significant differences: (1) the Queue2 representation has three fields (instance variables): preFront, rear, and length, while Stack2 only has two fields: top and length; (2) the singly-linked list representing Queue2 has one extra "smart" node at the front of the list, while the singly-linked list representing Stack2 does not include this extra node. 4. Develop a complete test plan for the Stack2 constructor and kernel methods you implemented and enter them in StackTest. package components.queue; import java.util.Iterator; import java.util.NoSuchElementException; /** * {@code Queue} represented as a singly linked list, done "bare-handed", with * implementations of primary methods. * * <p> * Execution-time performance of all methods implemented in this class is O(1). * * @param <T> * type of {@code Queue} entries * @convention <pre> * $this.length >= 0 and * [$this.preFront is not null] and * [$this.rear is not null] and * [$this.preFront points to the first node of a singly linked list * containing $this.length + 1 nodes] and * [$this.rear points to the last node in that singly linked list] and * [$this.rear.next is null] * </pre> * @correspondence <pre> * this = [data in nodes starting at $this.preFront.next and * running through $this.rear] * </pre> */ public class Queue2<T> extends QueueSecondary<T> { /* * Private members -------------------------------------------------------- */ /** * Node class for singly linked list nodes. */ private final class Node { /** * Data in node. */ private T data; /** * Next node in singly linked list, or null. */ private Node next; } /** * "Smart node" before front node of singly linked list. */ private Node preFront; /** * Rear node of singly linked list. */ private Node rear; /** * One less than number of nodes in singly linked list, i.e., length = * |this|. */ private int length; /** * Creator of initial representation. */ private void createNewRep() { this.preFront = new Node(); this.preFront.next = null; this.rear = this.preFront; this.length = 0; } /* * Constructors ----------------------------------------------------------- */ /** * Np-argument constructor. */ public Queue2() { this.createNewRep(); } /* * Standard methods removed to reduce clutter... */ /* * Kernel methods --------------------------------------------------------- */ @Override public final void enqueue(T x) { assert x != null : "Violation of: x is not null"; Node p = new Node(); Node q = this.rear; p.data = x; p.next = null; q.next = p; this.rear = p; this.length++; } @Override public final T dequeue() { assert this.length() > 0 : "Violation of: this /= <>"; Node p = this.preFront; Node q = p.next; T result = q.data; this.preFront = q; this.length--; return result; } @Override public final int length() { return this.length; } /* * Iterator code removed to reduce clutter... */ /* * Other methods (overridden for performance reasons) --------------------- */ @Override public final T front() { assert this.length() > 0 : "Violation of: this /= <>"; return this.preFront.next.data; } @Override public final T replaceFront(T x) { assert this.length() > 0 : "Violation of: this /= <>"; T front = this.preFront.next.data; this.preFront.next.data = x; return front; } } import java.util.Iterator; import java.util.NoSuchElementException; import components.stack.Stack; import components.stack.StackSecondary; /** * {@code Stack} represented as a singly linked list, done "bare-handed", with * implementations of primary methods. * * <p> * Execution-time performance of all methods implemented in this class is O(1). * * @param <T> * type of Stack entries * @convention <pre> * $this.length >= 0 and * if $this.length == 0 then * [$this.top is null] * else * [$this.top is not null] and * [$this.top points to the first node of a singly linked list * containing $this.length nodes] and * [next in the last node of that list is null] * </pre> * @correspondence this = [data in $this.length nodes starting at $this.top] */ public class Stack2<T> extends StackSecondary<T> { /* * Private members -------------------------------------------------------- */ /** * Node class for singly linked list nodes. */ private final class Node { /** * Data in node. */ private T data; /** * Next node in singly linked list, or null. */ private Node next; } /** * Top node of singly linked list. */ private Node top; /** * Number of nodes in singly linked list, i.e., length = |this|. */ private int length; /** * Creator of initial representation. */ private void createNewRep() { // TODO - fill in body } /* * Constructors ----------------------------------------------------------- */ /** * No-argument constructor. */ public Stack2() { this.createNewRep(); } /* * Standard methods removed to reduce clutter... */ /* * Kernel methods --------------------------------------------------------- */ @Override public final void push(T x) { assert x != null : "Violation of: x is not null"; // TODO - fill in body } @Override public final T pop() { assert this.length() > 0 : "Violation of: this /= <>"; // TODO - fill in body } @Override public final int length() { // TODO - fill in body } /* * Iterator code removed to reduce clutter... */ } import components.stack.Stack; /** * JUnit test fixture for {@code Stack<String>}'s constructor and kernel * methods. * * @author Put your name here * */ public abstract class StackTest { /** * Invokes the appropriate {@code Stack} constructor for the implementation * under test and returns the result. * * @return the new stack * @ensures constructorTest = <> */ protected abstract Stack<String> constructorTest(); /** * Invokes the appropriate {@code Stack} constructor for the reference * implementation and returns the result. * * @return the new stack * @ensures constructorRef = <> */ protected abstract Stack<String> constructorRef(); /** * * Creates and returns a {@code Stack<String>} of the implementation under * test type with the given entries. * * @param args * the entries for the stack * @return the constructed stack * @ensures createFromArgsTest = [entries in args] */ private Stack<String> createFromArgsTest(String... args) { Stack<String> stack = this.constructorTest(); for (String s : args) { stack.push(s); } stack.flip(); return stack; } /** * * Creates and returns a {@code Stack<String>} of the reference * implementation type with the given entries. * * @param args * the entries for the stack * @return the constructed stack * @ensures createFromArgsRef = [entries in args] */ private Stack<String> createFromArgsRef(String... args) { Stack<String> stack = this.constructorRef(); for (String s : args) { stack.push(s); } stack.flip(); return stack; } // TODO - add test cases for constructor, push, pop, and length }
|
07c4ed356978f2f791fc43ececf39870
|
{
"intermediate": 0.3600888252258301,
"beginner": 0.3939896821975708,
"expert": 0.2459215223789215
}
|
37,983
|
Carefully review the Stack2 skeleton of Stack kernel represented as a singly-linked list of Nodes. In particular, look at the representation fields and the convention and correspondence, and draw a picture (in the style used in the Linked Data Structures slides) of the representation a Stack2 object should have right after the constructor is executed.
import java.util.Iterator;
import java.util.NoSuchElementException;
import components.stack.Stack;
import components.stack.StackSecondary;
/**
* {@code Stack} represented as a singly linked list, done "bare-handed", with
* implementations of primary methods.
*
* <p>
* Execution-time performance of all methods implemented in this class is O(1).
*
* @param <T>
* type of Stack entries
* @convention <pre>
* $this.length >= 0 and
* if $this.length == 0 then
* [$this.top is null]
* else
* [$this.top is not null] and
* [$this.top points to the first node of a singly linked list
* containing $this.length nodes] and
* [next in the last node of that list is null]
* </pre>
* @correspondence this = [data in $this.length nodes starting at $this.top]
*/
public class Stack2<T> extends StackSecondary<T> {
/*
* Private members --------------------------------------------------------
*/
/**
* Node class for singly linked list nodes.
*/
private final class Node {
/**
* Data in node.
*/
private T data;
/**
* Next node in singly linked list, or null.
*/
private Node next;
}
/**
* Top node of singly linked list.
*/
private Node top;
/**
* Number of nodes in singly linked list, i.e., length = |this|.
*/
private int length;
/**
* Creator of initial representation.
*/
private void createNewRep() {
// TODO - fill in body
}
/*
* Constructors -----------------------------------------------------------
*/
/**
* No-argument constructor.
*/
public Stack2() {
this.createNewRep();
}
/*
* Standard methods removed to reduce clutter...
*/
/*
* Kernel methods ---------------------------------------------------------
*/
@Override
public final void push(T x) {
assert x != null : "Violation of: x is not null";
// TODO - fill in body
}
@Override
public final T pop() {
assert this.length() > 0 : "Violation of: this /= <>";
// TODO - fill in body
}
@Override
public final int length() {
// TODO - fill in body
}
/*
* Iterator code removed to reduce clutter...
*/
}
|
0e998fccb79cb8229572bf2cbf4305df
|
{
"intermediate": 0.2518717646598816,
"beginner": 0.409463495016098,
"expert": 0.338664710521698
}
|
37,984
|
Complete the implementation of the Stack kernel represented as a singly-linked list of Nodes in the skeleton provided, Stack2. You need to write bodies for the private method createNewRep and for the kernel methods push, pop, and length.
import java.util.Iterator;
import java.util.NoSuchElementException;
import components.stack.Stack;
import components.stack.StackSecondary;
/**
* {@code Stack} represented as a singly linked list, done "bare-handed", with
* implementations of primary methods.
*
* <p>
* Execution-time performance of all methods implemented in this class is O(1).
*
* @param <T>
* type of Stack entries
* @convention <pre>
* $this.length >= 0 and
* if $this.length == 0 then
* [$this.top is null]
* else
* [$this.top is not null] and
* [$this.top points to the first node of a singly linked list
* containing $this.length nodes] and
* [next in the last node of that list is null]
* </pre>
* @correspondence this = [data in $this.length nodes starting at $this.top]
*/
public class Stack2<T> extends StackSecondary<T> {
/*
* Private members --------------------------------------------------------
*/
/**
* Node class for singly linked list nodes.
*/
private final class Node {
/**
* Data in node.
*/
private T data;
/**
* Next node in singly linked list, or null.
*/
private Node next;
}
/**
* Top node of singly linked list.
*/
private Node top;
/**
* Number of nodes in singly linked list, i.e., length = |this|.
*/
private int length;
/**
* Creator of initial representation.
*/
private void createNewRep() {
// TODO - fill in body
}
/*
* Constructors -----------------------------------------------------------
*/
/**
* No-argument constructor.
*/
public Stack2() {
this.createNewRep();
}
/*
* Standard methods removed to reduce clutter...
*/
/*
* Kernel methods ---------------------------------------------------------
*/
@Override
public final void push(T x) {
assert x != null : "Violation of: x is not null";
// TODO - fill in body
}
@Override
public final T pop() {
assert this.length() > 0 : "Violation of: this /= <>";
// TODO - fill in body
}
@Override
public final int length() {
// TODO - fill in body
}
/*
* Iterator code removed to reduce clutter...
*/
}
|
cf036e6807385e23a6c601087facdfbb
|
{
"intermediate": 0.27223286032676697,
"beginner": 0.39879900217056274,
"expert": 0.3289681077003479
}
|
37,985
|
Can you show an example of implementing a Serializable interface in Java using transient fields and that handles serialisation of objects that are not serialiazble?
|
7dcaa342a190b35552a6bc444666f0e3
|
{
"intermediate": 0.8219706416130066,
"beginner": 0.05257536470890045,
"expert": 0.12545397877693176
}
|
37,986
|
delete any variable from session flask
|
ccd758d74dd303c383af5bd7aa6e1a04
|
{
"intermediate": 0.3625412583351135,
"beginner": 0.4164576232433319,
"expert": 0.22100107371807098
}
|
37,987
|
why doesn't this code print the <h3> tags in terminal?
if(object2 == "y"):
# asking if user wants a recent search, then printing in terminal
print("Complete a recent scrape on " + object + "? (y/n)\nAdds:\n'after:currentyear - 1'META TAG")
recentSearchScrape = input("")
if(recentSearchScrape == "y"):
def recentSearch():
recent_year = datetime.now().year - 1
query = object + " after:" + str(recent_year)
webbrowser.open_new_tab(url + query)
# Fetch the URL data using requests.get(url),
# store it in a variable, query_result
query_result = requests.get(url)
soup = bs4.BeautifulSoup(query_result.text, "html.parser")
# soup.find.all( h3 ) to grab
# all major headings of our search result,
h3_tags = soup.find_all("h3")
# Iterate through the object
# and print it as a string.
for info in h3_tags:
print(info.getText())
print("\n")
print(h3_tags)
print(soup)
recentSearch()
|
b76fa739f42e2023984b0a1fc032545c
|
{
"intermediate": 0.3749946057796478,
"beginner": 0.5404321551322937,
"expert": 0.08457327634096146
}
|
37,988
|
pyinstaller --onefile -w -F -i icon.ico --upx-dir="C:\upx-4.2.2" --add-data "a.wav;." --add-data "b.wav;." script.pyw
in nuitka, what commands give same output
|
e297cb890176bfe9b78c53c27233b371
|
{
"intermediate": 0.3937267065048218,
"beginner": 0.377799928188324,
"expert": 0.22847335040569305
}
|
37,989
|
Override a function called bot.chat. It calls the original bot.chat but it has a delay for sending, which is 500 ms. Any messages that is being delayed is added to an array and sent whent he cooldown is over
|
d3bf3310d1c553fd578a363aec1a85e3
|
{
"intermediate": 0.30040016770362854,
"beginner": 0.27301502227783203,
"expert": 0.42658481001853943
}
|
37,990
|
The following is an error thrown by New Relic. It's a SyntaxError so it doesn't have a stack trace. Please give options to find the origin of the error:
|
f46716d665a1d4e76581a5935f0c752e
|
{
"intermediate": 0.36640822887420654,
"beginner": 0.3689303398132324,
"expert": 0.26466143131256104
}
|
37,991
|
how can solve gpu consume when use trainer.train for finetuning llm
|
3515969c4def47907148c80fad703bc2
|
{
"intermediate": 0.2574312686920166,
"beginner": 0.15045852959156036,
"expert": 0.5921102166175842
}
|
37,992
|
GI
|
04fa81b25815a39caeeeef6bd2e639d4
|
{
"intermediate": 0.36124253273010254,
"beginner": 0.22393308579921722,
"expert": 0.41482436656951904
}
|
37,993
|
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset
from collections import Counter
import json
from tqdm import tqdm
# Expert LSTM Model
class LSTMExpert(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(LSTMExpert, self).__init__()
self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, x):
h, _ = self.lstm(x)
# Shape of h: [batch_size, sequence_length, hidden_size]
# No longer taking the last sequence output, transform for all time steps
h = h.reshape(-1, h.shape[2]) # Flatten to two dimensions: [batch_size * sequence_length, hidden_size]
return self.fc(h)
# Gating Network
class GatingNetwork(nn.Module):
def __init__(self, input_size, num_experts):
super(GatingNetwork, self).__init__()
self.fc = nn.Linear(input_size, num_experts)
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
if x.dim() > 2:
x = x.view(x.size(0), -1) # Flatten the tensor correctly
x = self.fc(x)
return self.softmax(x)
# Mixture of Experts Model
class MixtureOfExperts(nn.Module):
def __init__(self, input_size, hidden_size, output_size, num_experts):
super(MixtureOfExperts, self).__init__()
self.num_experts = num_experts
self.experts = nn.ModuleList([LSTMExpert(input_size, hidden_size, output_size) for _ in range(num_experts)])
self.gating_network = GatingNetwork(input_size, num_experts)
def forward(self, x):
# Flatten x for gating input: [batch_size * sequence_length, input_size]
gating_input = x.contiguous().view(-1, x.shape[-1])
# Get gating scores for each expert: [batch_size * sequence_length, num_experts, 1]
gating_scores = self.gating_network(gating_input).view(-1, self.num_experts, 1)
# Compute outputs from each expert
expert_outputs = [expert(x) for expert in self.experts] # List of [batch_size * sequence_length, vocab_size] tensors
# Stack along a new dimension for experts: [batch_size * sequence_length, vocab_size, num_experts]
expert_outputs = torch.stack(expert_outputs, dim=2)
# Calculate weighted sum of expert outputs: [batch_size * sequence_length, vocab_size]
mixed_output = torch.bmm(expert_outputs, gating_scores) # [batch_size * sequence_length, vocab_size, 1]
mixed_output = mixed_output.squeeze(-1) # Remove last singleton dimension
return mixed_output
class QAJsonlDataset(Dataset):
def __init__(self, path, seq_len):
self.seq_len = seq_len
self.pairs = self.load_data(path)
# Flatten the pairs completely before passing them to build_vocab
self.vocab, self.idx2token = self.build_vocab([word for pair in self.pairs for sublist in pair for word in sublist])
self.tokenized_pairs = [(self.tokenize(q), self.tokenize(a)) for q, a in self.pairs]
def load_data(self, path):
pairs = []
with open(path, "r", encoding="utf-8") as f:
for line in f:
data = json.loads(line.strip())
question, answer = data.get("question", ""), data.get("answer", "")
pairs.append((question.split(), answer.split()))
return pairs
def tokenize(self, words):
# Tokenize a sentence and pad if necessary
# Add <eos> token at the end if there’s room
tokens = [self.vocab.get(w, self.vocab["<unk>"]) for w in words]
if len(tokens) < self.seq_len:
tokens.append(self.vocab["<eos>"]) # Add <eos> token
tokens.extend([self.vocab["<pad>"]] * (self.seq_len - len(tokens))) # Pad the rest
else:
tokens = tokens[:self.seq_len - 1] + [self.vocab["<eos>"]]
return tokens
def build_vocab(self, words):
# Start with special tokens with fixed indices
vocab = {"<unk>": 0, "<pad>": 1, "<eos>": 2}
start_index = len(vocab)
# Use Counter to count word frequencies in the corpus
counts = Counter(words)
# Create the vocab dictionary with all words, starting indices after the special tokens
for word, _ in counts.most_common():
if word not in vocab: # Skip special tokens
vocab[word] = len(vocab)
# Create the reverse mapping from indices to words
idx2token = {idx: token for token, idx in vocab.items()}
return vocab, idx2token
def __len__(self):
return len(self.tokenized_pairs)
def __getitem__(self, idx):
tokenized_question, tokenized_answer = self.tokenized_pairs[idx]
return torch.tensor(tokenized_question, dtype=torch.long), torch.tensor(tokenized_answer, dtype=torch.long)
def collate_fn(batch):
questions, answers = zip(*batch)
questions = pad_sequence(questions, batch_first=True, padding_value=0)
answers = pad_sequence(answers, batch_first=True, padding_value=0)
return questions, answers
# Set the path to your text file and define sequence length
path_to_text = 'GSM2K.jsonl' # replace with the path to your text file
seq_len = 72 # sequence length
# Create a dataset and data loader
dataset = QAJsonlDataset(path_to_text, seq_len)
data_loader = DataLoader(dataset, batch_size=72, shuffle=True, collate_fn=collate_fn)
def train_model_TXT(model, criterion, optimizer, num_epochs, data_loader):
model.train()
for epoch in range(num_epochs):
total_loss = 0
# Wrap the data loader with tqdm for the progress bar
data_loader = tqdm(data_loader, desc=f"Epoch {epoch+1}", leave=False)
for i, (inputs, targets) in enumerate(data_loader):
optimizer.zero_grad()
# Forward pass
predictions = model(inputs)
# Flatten targets to be [batch_size * sequence_length]
targets = targets.view(-1)
# Flatten predictions to be [batch_size * sequence_length, num_classes]
predictions = predictions.view(-1, predictions.size(-1))
# Loss computation
loss = criterion(predictions, targets)
loss.backward()
optimizer.step()
total_loss += loss.item()
# Update the tqdm progress bar
data_loader.set_postfix({"Loss": loss.item()})
average_loss = total_loss / len(data_loader.dataset)
print(f"Epoch {epoch+1}, Loss: {average_loss}")
def generate_text(model, dataset, seed_text, num_generate, temperature=1.0):
model.eval() # Put the model in evaluation mode
# List to store the generated tokens
generated_tokens = []
# Initial sequence (prefix) to start the generation process
input_sequence = [dataset.vocab.get(word, dataset.vocab["<pad>"]) for word in seed_text.split()] # Convert to token IDs
current_sequence = torch.tensor(input_sequence, dtype=torch.long).unsqueeze(0)
# Generate num_generate tokens
for _ in range(num_generate):
# Forward pass through the model
with torch.no_grad():
output = model(current_sequence)
# Get probabilities, apply temperature scaling, and sample from the distribution
probabilities = F.softmax(output[-1] / temperature, dim=0).detach()
next_token_idx = torch.multinomial(probabilities, 1).item()
# Append token to the current sequence and to the generated tokens
generated_tokens.append(next_token_idx)
current_sequence = torch.cat((current_sequence, torch.tensor([[next_token_idx]])), 1)
# Convert tokens to words
generated_text = " ".join([dataset.idx2token.get(token, "<unk>") for token in generated_tokens]) # Use .get() to provide a default value for missing keys
return generated_text
# Integration of MoE with the rest of the code
vocab_size = len(dataset.vocab) # The size of the vocabulary
embedding_dim = 128 # Size of embeddings
hidden_size = 256 # Number of features in the hidden state of the LSTM
num_experts = 2 # Define the number of LSTM experts you want in your MoE model
# Instantiate the MixtureOfExperts model
mixture_of_experts_model = MixtureOfExperts(embedding_dim, hidden_size, vocab_size, num_experts)
# Wrap the experts and the embedding layer into a new combined model, replacing SingleLSTM_TXT
class MoEModel(nn.Module):
def __init__(self, embedding_dim, vocab_size, MoE):
super(MoEModel, self).__init__()
self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
self.MoE = MoE
def forward(self, x):
embedded = self.embedding(x)
output = self.MoE(embedded)
return output
# Instantiate the MoEModel with embeddings and mixture of experts
moe_model = MoEModel(embedding_dim, vocab_size, mixture_of_experts_model)
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
# Example usage with your model:
total_params = count_parameters(moe_model)
print(f"Total trainable parameters: {total_params}")
# Training parameters
num_epochs = 2
batch_size = 32
learning_rate = 1e-3
# Define Loss Function and Optimizer for MoE model
criterion = nn.CrossEntropyLoss() # Use CrossEntropyLoss for classification tasks
optimizer = torch.optim.Adam(moe_model.parameters(), lr=learning_rate)
# Replace references to single_lstm_txt_model with moe_model
# Train the model with the text data
train_model_TXT(moe_model, criterion, optimizer, num_epochs, data_loader)
# Start a loop for the interactive chat-like text generation
while True:
try:
# Get user input
seed_text = input("Enter seed text (type 'quit' to stop): ")
# Check if user wants to quit the interaction
if seed_text.lower() == "quit":
print("Exiting text generation chat.")
break
# User input is not empty and not “quit”, generate text
if seed_text.strip():
num_generate = 16 # Number of words to generate
temperature = 0.5 # Sampling temperature, higher will increase diversity
# Use the trained model to generate text
generated_text = generate_text(moe_model, dataset, seed_text, num_generate, temperature)
print("Generated Text:", generated_text)
else:
print("Seed text cannot be empty.")
except KeyboardInterrupt:
# Handle KeyboardInterrupt (Ctrl+C) to gracefully exit
print("\nExiting text generation chat.")
break
|
b6d695b7950acfb8884ccdd1c4c2e0cb
|
{
"intermediate": 0.3089928925037384,
"beginner": 0.4218018054962158,
"expert": 0.26920533180236816
}
|
37,994
|
models\connexion.php
<?php
require_once dirname(__DIR__) . '/Classes/autoloader.php';
require_once 'Database.php';
Autoloader::register();
$pdo = Database::getInstance();
$pdo->exec("
CREATE TABLE IF NOT EXISTS quizzes (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
)
");
|
aedebce62bf36c9c1c960e089e9d41c6
|
{
"intermediate": 0.37829968333244324,
"beginner": 0.44610902667045593,
"expert": 0.17559130489826202
}
|
37,995
|
how can solve gpu consume when use trainer.train for finetuning llm code technique
|
58c9919221e71a97d733ac12bf41a794
|
{
"intermediate": 0.1736927628517151,
"beginner": 0.1343550980091095,
"expert": 0.691952109336853
}
|
37,996
|
Total trainable parameters: 14652208
Epoch 1, Loss: 0.0006209480017423629
Epoch 2, Loss: 0.0006110855117440224
Epoch 3, Loss: 0.0005957057364284992
Epoch 4, Loss: 0.0005752133391797543
Epoch 5, Loss: 0.0005297200903296471
Epoch 6, Loss: 0.0004764240626245737
Epoch 7, Loss: 0.00044754338264465333
Epoch 8, Loss: 0.0004309039544314146
Epoch 9: 62%|██████████████████████████████████████████████████████████████████▉ | 10/16 [01:34<00:55, 9.20s/it, Loss=6.65]
|
504b7eed4ef901ed60c58319d4ca2df0
|
{
"intermediate": 0.274515837430954,
"beginner": 0.27979159355163574,
"expert": 0.44569259881973267
}
|
37,997
|
Fix the code and return the filtered one, no talk, just raw code, no more than that, return the full like, be a respectful and helpful agent, here is the code, remember the instruction: import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset
from collections import Counter
import json
from tqdm import tqdm
import math
def positional_encoding(seq_len, d_model, device):
# Generate the positions
pos = torch.arange(seq_len).unsqueeze(1) # [seq_len, 1]
# Generate the dividers for the positions
div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)).unsqueeze(0)
# Compute the positional encodings: sinusoids of different frequencies
pe = torch.zeros((seq_len, d_model), device=device)
pe[:, 0::2] = torch.sin(pos.float() * div_term)
pe[:, 1::2] = torch.cos(pos.float() * div_term)
return pe.unsqueeze(0)
class SimpleTransformer(nn.Module):
def __init__(self, input_size, d_model, output_size, nhead, dim_feedforward, num_encoder_layers=1):
super(SimpleTransformer, self).__init__()
self.d_model = d_model
self.input_fc = nn.Linear(input_size, d_model) # Linear layer to project to model dimension
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model,
nhead=nhead,
dim_feedforward=dim_feedforward,
batch_first=True) # Added batch_first=True
self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_encoder_layers)
self.output_fc = nn.Linear(d_model, output_size)
def forward(self, x):
batch_size, seq_len, _ = x.size()
x = self.input_fc(x) + positional_encoding(seq_len, self.d_model, x.device)
transformer_output = self.transformer_encoder(x)
output = self.output_fc(transformer_output[:, -1, :]) # Taking the result from the last sequence element
return output
# Expert Transformer Model
class TransformerExpert(nn.Module):
def __init__(self, input_size, d_model, output_size, nhead, dim_feedforward, num_encoder_layers=1):
super(TransformerExpert, self).__init__()
self.d_model = d_model
self.input_fc = nn.Linear(input_size, d_model) # Linear layer to project to model dimension
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, batch_first=True)
self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_encoder_layers)
self.output_fc = nn.Linear(d_model, output_size)
def forward(self, x):
x = self.input_fc(x)
x += positional_encoding(x.size(1), self.d_model, x.device)
transformer_output = self.transformer_encoder(x)
transformer_output = transformer_output[:, -1, :]
output = self.output_fc(transformer_output)
return output
# Gating Network
class GatingNetwork(nn.Module):
def __init__(self, input_size, num_experts):
super(GatingNetwork, self).__init__()
self.fc = nn.Linear(input_size, num_experts)
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
if x.dim() > 2:
x = x.view(x.size(0), -1) # Flatten the tensor correctly
x = self.fc(x)
return self.softmax(x)
# Mixture of Experts Model
class MixtureOfTransformerExperts(nn.Module):
def __init__(self, input_size, d_model, output_size, nhead, dim_feedforward, num_experts, num_encoder_layers=1):
super(MixtureOfTransformerExperts, self).__init__()
self.num_experts = num_experts
self.experts = nn.ModuleList([TransformerExpert(input_size, d_model, output_size, nhead, dim_feedforward, num_encoder_layers)
for _ in range(num_experts)])
self.gating_network = GatingNetwork(d_model, num_experts)
def forward(self, x):
x = x.contiguous().view(-1, x.shape[-1])
gating_scores = self.gating_network(x).view(-1, self.num_experts, 1)
x = x.contiguous().view(-1, 1, x.shape[1])
expert_outputs = [expert(x).view(-1, 1, x.shape[-1]) for expert in self.experts]
expert_outputs = torch.cat(expert_outputs, dim=1)
mixed_output = torch.bmm(expert_outputs, gating_scores)
mixed_output = mixed_output.squeeze(-1)
return mixed_output
class QAJsonlDataset(Dataset):
def __init__(self, path, seq_len):
self.seq_len = seq_len
self.pairs = self.load_data(path)
# Flatten the pairs completely before passing them to build_vocab
self.vocab, self.idx2token = self.build_vocab([word for pair in self.pairs for sublist in pair for word in sublist])
self.tokenized_pairs = [(self.tokenize(q), self.tokenize(a)) for q, a in self.pairs]
def load_data(self, path):
pairs = []
with open(path, "r", encoding="utf-8") as f:
for line in f:
data = json.loads(line.strip())
question, answer = data.get("question", ""), data.get("answer", "")
pairs.append((question.split(), answer.split()))
return pairs
def tokenize(self, words):
# Tokenize a sentence and pad if necessary
# Add <eos> token at the end if there’s room
tokens = [self.vocab.get(w, self.vocab["<unk>"]) for w in words]
if len(tokens) < self.seq_len:
tokens.append(self.vocab["<eos>"]) # Add <eos> token
tokens.extend([self.vocab["<pad>"]] * (self.seq_len - len(tokens))) # Pad the rest
else:
tokens = tokens[:self.seq_len - 1] + [self.vocab["<eos>"]]
return tokens
def build_vocab(self, words):
# Start with special tokens with fixed indices
vocab = {"<unk>": 0, "<pad>": 1, "<eos>": 2}
start_index = len(vocab)
# Use Counter to count word frequencies in the corpus
counts = Counter(words)
# Create the vocab dictionary with all words, starting indices after the special tokens
for word, _ in counts.most_common():
if word not in vocab: # Skip special tokens
vocab[word] = len(vocab)
# Create the reverse mapping from indices to words
idx2token = {idx: token for token, idx in vocab.items()}
return vocab, idx2token
def __len__(self):
return len(self.tokenized_pairs)
def __getitem__(self, idx):
tokenized_question, tokenized_answer = self.tokenized_pairs[idx]
return torch.tensor(tokenized_question, dtype=torch.long), torch.tensor(tokenized_answer, dtype=torch.long)
def collate_fn(batch):
questions, answers = zip(*batch)
questions = pad_sequence(questions, batch_first=True, padding_value=0)
answers = pad_sequence(answers, batch_first=True, padding_value=0)
return questions, answers
# Set the path to your text file and define sequence length
path_to_text = 'GSM2K.jsonl' # replace with the path to your text file
seq_len = 64 # sequence length
# Create a dataset and data loader
dataset = QAJsonlDataset(path_to_text, seq_len)
data_loader = DataLoader(dataset, batch_size=128, shuffle=True, collate_fn=collate_fn)
def train_model_TXT(model, criterion, optimizer, num_epochs, data_loader):
model.train()
for epoch in range(num_epochs):
total_loss = 0
progress_bar = tqdm(enumerate(data_loader), total=len(data_loader), desc=f"Epoch {epoch+1}", leave=False)
for i, (inputs, targets) in progress_bar:
optimizer.zero_grad()
# Forward pass
predictions = model(inputs)
# Flatten targets to be [batch_size * sequence_length]
targets = targets.view(-1)
# Flatten predictions to be [batch_size * sequence_length, num_classes]
predictions = predictions.view(-1, predictions.size(-1))
# Loss computation
loss = criterion(predictions, targets)
loss.backward()
optimizer.step()
total_loss += loss.item()
# Update the tqdm progress bar
progress_bar.set_postfix({"Loss": loss.item()})
average_loss = total_loss / len(data_loader.dataset)
print(f"Epoch {epoch+1}, Loss: {average_loss}")
def generate_text(model, dataset, seed_text, num_generate, temperature=1.0):
model.eval() # Put the model in evaluation mode
# List to store the generated tokens
generated_tokens = []
# Initial sequence (prefix) to start the generation process
input_sequence = [dataset.vocab.get(word, dataset.vocab["<pad>"]) for word in seed_text.split()] # Convert to token IDs
current_sequence = torch.tensor(input_sequence, dtype=torch.long).unsqueeze(0)
# Generate num_generate tokens
for _ in range(num_generate):
# Forward pass through the model
with torch.no_grad():
output = model(current_sequence)
# Get probabilities, apply temperature scaling, and sample from the distribution
probabilities = F.softmax(output[-1] / temperature, dim=0).detach()
next_token_idx = torch.multinomial(probabilities, 1).item()
# Append token to the current sequence and to the generated tokens
generated_tokens.append(next_token_idx)
current_sequence = torch.cat((current_sequence, torch.tensor([[next_token_idx]])), 1)
# Convert tokens to words
generated_text = " ".join([dataset.idx2token.get(token, "<unk>") for token in generated_tokens]) # Use .get() to provide a default value for missing keys
return generated_text
# Define hyperparameters specific to the transformer
d_model = 256
nhead = 8
dim_feedforward = 1024
num_encoder_layers = 1
# Instantiate resulting MoE transformer model
moe_transformer_model = MoETransformerModel(
vocab_size=vocab_size,
d_model=d_model,
MoE=MixtureOfTransformerExperts(
input_size=embedding_dim,
d_model=d_model,
output_size=vocab_size,
nhead=nhead,
dim_feedforward=dim_feedforward,
num_experts=num_experts,
num_encoder_layers=num_encoder_layers
)
)
# Wrap the experts and the embedding layer into a new combined model, replacing SingleLSTM_TXT
class MoETransformerModel(nn.Module):
def init(self, vocab_size, d_model, MoE):
super(MoETransformerModel, self).init()
self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=d_model)
self.MoE = MoE
def forward(self, x):
embedded = self.embedding(x) + positional_encoding(x.size(1), d_model, x.device)
output = self.MoE(embedded)
return output
# Instantiate the MoEModel with embeddings and mixture of experts
moe_model = MoEModel(embedding_dim, vocab_size, mixture_of_experts_model)
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
# Example usage with your model:
total_params = count_parameters(moe_transformer_model)
print(f"Total trainable parameters: {total_params}")
# Training parameters
num_epochs = 12
batch_size = 128
learning_rate = 1e-4
# Define Loss Function and Optimizer for MoE model
criterion = nn.CrossEntropyLoss() # Use CrossEntropyLoss for classification tasks
optimizer = torch.optim.Adam(moe_transformer_model.parameters(), lr=learning_rate)
# Replace references to single_lstm_txt_model with moe_model
# Train the model with the text data
train_model_TXT(moe_transformer_model, criterion, optimizer, num_epochs, data_loader)
# Start a loop for the interactive chat-like text generation
while True:
try:
# Get user input
seed_text = input("Enter seed text (type 'quit' to stop): ")
# Check if user wants to quit the interaction
if seed_text.lower() == "quit":
print("Exiting text generation chat.")
break
# User input is not empty and not “quit”, generate text
if seed_text.strip():
num_generate = 16 # Number of words to generate
temperature = 1.0 # Sampling temperature, higher will increase diversity
# Use the trained model to generate text
generated_text = generate_text(moe_transformer_model, dataset, seed_text, num_generate, temperature)
print("Generated Text:", generated_text)
else:
print("Seed text cannot be empty.")
except KeyboardInterrupt:
# Handle KeyboardInterrupt (Ctrl+C) to gracefully exit
print("\nExiting text generation chat.")
break
torch.save(moe_transformer_model.state_dict(), "MoE_LSTM-X2-14M-QA.pth")
|
b18aaf9af326bcb16be94f8fb3446468
|
{
"intermediate": 0.266017347574234,
"beginner": 0.45474866032600403,
"expert": 0.2792339622974396
}
|
37,998
|
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset
from collections import Counter
import json
from tqdm import tqdm
import math
def positional_encoding(seq_len, d_model, device):
pos = torch.arange(seq_len, dtype=torch.float, device=device).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)).to(device)
pe = torch.zeros(seq_len, d_model, device=device)
pe[:, 0::2] = torch.sin(pos * div_term)
pe[:, 1::2] = torch.cos(pos * div_term)
return pe.unsqueeze(0)
# Expert Transformer Model
class TransformerExpert(nn.Module):
def __init__(self, input_size, d_model, output_size, nhead, dim_feedforward, num_encoder_layers=1):
super(TransformerExpert, self).__init__()
self.d_model = d_model
self.input_fc = nn.Linear(input_size, d_model)
encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, batch_first=True)
self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_encoder_layers)
self.output_fc = nn.Linear(d_model, output_size)
def forward(self, x):
x = self.input_fc(x) + positional_encoding(x.size(1), self.d_model, x.device)
transformer_output = self.transformer_encoder(x)
output = self.output_fc(transformer_output[:, -1, :])
return output
# Gating Network
class GatingNetwork(nn.Module):
def __init__(self, input_size, num_experts):
super(GatingNetwork, self).__init__()
self.fc = nn.Linear(input_size, num_experts)
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
if x.dim() > 2:
x = x.view(x.size(0), -1)
# Flatten the tensor correctly
x = self.fc(x)
return self.softmax(x)
# Mixture of Experts Model
class MixtureOfTransformerExperts(nn.Module):
def __init__(self, input_size, d_model, output_size, nhead, dim_feedforward, num_experts, num_encoder_layers=1):
super(MixtureOfTransformerExperts, self).__init__()
self.num_experts = num_experts
self.experts = nn.ModuleList([TransformerExpert(input_size, d_model, output_size, nhead, dim_feedforward, num_encoder_layers) for _ in range(num_experts)])
self.gating_network = GatingNetwork(d_model, num_experts)
def forward(self, x):
gating_scores = self.gating_network(x)
expert_outputs = [expert(x).unsqueeze(1) for expert in self.experts]
expert_outputs = torch.cat(expert_outputs, dim=1) # shape: [batch, num_experts, output_size]
mixed_output = torch.bmm(expert_outputs.permute(0, 2, 1), gating_scores.unsqueeze(-1)).squeeze(-1)
return mixed_output
class QAJsonlDataset(Dataset):
def __init__(self, path, seq_len):
self.seq_len = seq_len
self.pairs = self.load_data(path)
# Flatten the pairs completely before passing them to build_vocab
self.vocab, self.idx2token = self.build_vocab([word for pair in self.pairs for sublist in pair for word in sublist])
self.tokenized_pairs = [(self.tokenize(q), self.tokenize(a)) for q, a in self.pairs]
def load_data(self, path):
pairs = []
with open(path, "r", encoding="utf-8") as f:
for line in f:
data = json.loads(line.strip())
question, answer = data.get("question", ""), data.get("answer", "")
pairs.append((question.split(), answer.split()))
return pairs
def tokenize(self, words):
# Tokenize a sentence and pad if necessary
# Add <eos> token at the end if there’s room
tokens = [self.vocab.get(w, self.vocab["<unk>"]) for w in words]
if len(tokens) < self.seq_len:
tokens.append(self.vocab["<eos>"]) # Add <eos> token
tokens.extend([self.vocab["<pad>"]] * (self.seq_len - len(tokens))) # Pad the rest
else:
tokens = tokens[:self.seq_len - 1] + [self.vocab["<eos>"]]
return tokens
def build_vocab(self, words):
# Start with special tokens with fixed indices
vocab = {"<unk>": 0, "<pad>": 1, "<eos>": 2}
start_index = len(vocab)
# Use Counter to count word frequencies in the corpus
counts = Counter(words)
# Create the vocab dictionary with all words, starting indices after the special tokens
for word, _ in counts.most_common():
if word not in vocab: # Skip special tokens
vocab[word] = len(vocab)
# Create the reverse mapping from indices to words
idx2token = {idx: token for token, idx in vocab.items()}
return vocab, idx2token
def __len__(self):
return len(self.tokenized_pairs)
def __getitem__(self, idx):
tokenized_question, tokenized_answer = self.tokenized_pairs[idx]
return torch.tensor(tokenized_question, dtype=torch.long), torch.tensor(tokenized_answer, dtype=torch.long)
class MoETransformerModel(nn.Module):
def __init__(self, vocab_size, d_model, moe):
super(MoETransformerModel, self).__init__()
self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=d_model)
self.moe = moe
self.dropout = nn.Dropout(p=0.1) # Dropout added for regularization
def forward(self, x):
embedded = self.dropout(self.embedding(x))
embedded_with_position = embedded + positional_encoding(x.size(1), d_model, x.device)
return self.moe(embedded_with_position)
def collate_fn(batch):
questions, answers = zip(*batch)
questions = pad_sequence(questions, batch_first=True, padding_value=0)
answers = pad_sequence(answers, batch_first=True, padding_value=0)
return questions, answers
# Set the path to your text file and define sequence length
path_to_text = 'GSM2K.jsonl' # replace with the path to your text file
seq_len = 64 # sequence length
# Create a dataset and data loader
dataset = QAJsonlDataset(path_to_text, seq_len)
data_loader = DataLoader(dataset, batch_size=128, shuffle=True, collate_fn=collate_fn, num_workers=4)
# Training loop - added gradient clipping to avoid exploding gradients
def train_model(model, criterion, optimizer, num_epochs, data_loader):
model.train()
for epoch in range(num_epochs):
total_loss = 0
progress_bar = tqdm(enumerate(data_loader), total=len(data_loader), desc=f"Epoch {epoch+1}", leave=False)
for i, (inputs, targets) in progress_bar:
optimizer.zero_grad()
predictions = model(inputs)
loss = criterion(predictions.view(-1, predictions.size(-1)), targets.view(-1))
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # Gradient clipping
optimizer.step()
total_loss += loss.item()
progress_bar.set_postfix({"Loss": loss.item()})
average_loss = total_loss / len(data_loader.dataset)
print(f"Epoch {epoch+1}, Average Loss: {average_loss}")
def generate_text(model, dataset, seed_text, num_generate, temperature=1.0):
model.eval() # Put the model in evaluation mode
# List to store the generated tokens
generated_tokens = []
# Initial sequence (prefix) to start the generation process
input_sequence = [dataset.vocab.get(word, dataset.vocab["<pad>"]) for word in seed_text.split()] # Convert to token IDs
current_sequence = torch.tensor(input_sequence, dtype=torch.long).unsqueeze(0)
# Generate num_generate tokens
for _ in range(num_generate):
# Forward pass through the model
with torch.no_grad():
output = model(current_sequence)
# Get probabilities, apply temperature scaling, and sample from the distribution
probabilities = F.softmax(output[-1] / temperature, dim=0).detach()
next_token_idx = torch.multinomial(probabilities, 1).item()
# Append token to the current sequence and to the generated tokens
generated_tokens.append(next_token_idx)
current_sequence = torch.cat((current_sequence, torch.tensor([[next_token_idx]])), 1)
# Convert tokens to words
generated_text = " ".join([dataset.idx2token.get(token, "<unk>") for token in generated_tokens]) # Use .get() to provide a default value for missing keys
return generated_text
# Define hyperparameters specific to the transformer
d_model = 128
nhead = 8
dim_feedforward = 256
num_encoder_layers = 2
num_experts = 2
vocab_size = len(dataset.vocab) # Assume dataset.vocab is defined in the QAJsonlDataset class
# Instantiate resulting MoE transformer model
moe = MixtureOfTransformerExperts(
input_size=d_model, # Assuming each word is represented by d_model features
d_model=d_model,
output_size=vocab_size, # Output size is the vocab size for token generation
nhead=nhead,
dim_feedforward=dim_feedforward,
num_experts=num_experts,
num_encoder_layers=num_encoder_layers
)
# Instantiate the MoE transformer model
moe_transformer_model = MoETransformerModel(vocab_size, d_model, moe)
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
# Example usage with your model:
total_params = count_parameters(moe_transformer_model)
print(f"Total trainable parameters: {total_params}")
# Training parameters
num_epochs = 4
learning_rate = 1e-4
# Define Loss Function and Optimizer for MoE model - using Label Smoothing for better generalization
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
optimizer = torch.optim.AdamW(moe_transformer_model.parameters(), lr=learning_rate, weight_decay=0.01) # Using AdamW with weight decay
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, "min")
# Replace references to single_lstm_txt_model with moe_model
# Train the model with the text data
train_model(moe_transformer_model, criterion, optimizer, num_epochs, data_loader)
# Start a loop for the interactive chat-like text generation
while True:
try:
# Get user input
seed_text = input("Enter seed text (type 'quit' to stop): ")
# Check if user wants to quit the interaction
if seed_text.lower() == "quit":
print("Exiting text generation chat.")
break
# User input is not empty and not “quit”, generate text
if seed_text.strip():
num_generate = 16 # Number of words to generate
temperature = 1.0 # Sampling temperature, higher will increase diversity
# Use the trained model to generate text
generated_text = generate_text(moe_transformer_model, dataset, seed_text, num_generate, temperature)
print("Generated Text:", generated_text)
else:
print("Seed text cannot be empty.")
except KeyboardInterrupt:
# Handle KeyboardInterrupt (Ctrl+C) to gracefully exit
print("\nExiting text generation chat.")
break
torch.save(moe_transformer_model.state_dict(), "MoE_Transformer-X2-9M-QA.pth")
|
8be577cce8c68456503c33ab9fd9fe12
|
{
"intermediate": 0.28839558362960815,
"beginner": 0.3940836787223816,
"expert": 0.31752079725265503
}
|
37,999
|
Don't reply: import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset
from collections import Counter
import json
from tqdm import tqdm
import math
def positional_encoding(seq_len, d_model, device):
pos = torch.arange(seq_len, dtype=torch.float, device=device).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)).to(device)
pe = torch.zeros(seq_len, d_model, device=device)
pe[:, 0::2] = torch.sin(pos * div_term)
pe[:, 1::2] = torch.cos(pos * div_term)
return pe.unsqueeze(0)
# Expert Transformer Model
class TransformerExpert(nn.Module):
def __init__(self, input_size, d_model, output_size, nhead, dim_feedforward, num_encoder_layers=1):
super(TransformerExpert, self).__init__()
self.d_model = d_model
self.input_fc = nn.Linear(input_size, d_model)
encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, batch_first=True)
self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_encoder_layers)
self.output_fc = nn.Linear(d_model, output_size)
def forward(self, x):
x = self.input_fc(x) + positional_encoding(x.size(1), self.d_model, x.device)
transformer_output = self.transformer_encoder(x)
output = self.output_fc(transformer_output[:, -1, :])
return output
# Gating Network
class GatingNetwork(nn.Module):
def __init__(self, input_feature_dim, num_experts):
super(GatingNetwork, self).__init__()
self.fc = nn.Linear(input_feature_dim, num_experts)
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
# Assuming x is of shape [batch_size, seq_len, d_model] you may want to aggregate
# across the sequence length dimension before the gating network
x = x.mean(dim=1) # Take mean or another operation that reduces seq_len dimension
x = self.fc(x) # Now the shape of x should match the weight matrix of the fc layer
return self.softmax(x)
# Mixture of Experts Model
class MixtureOfTransformerExperts(nn.Module):
def __init__(self, input_size, d_model, output_size, nhead, dim_feedforward, num_experts, num_encoder_layers=1):
super(MixtureOfTransformerExperts, self).__init__()
self.num_experts = num_experts
self.experts = nn.ModuleList([TransformerExpert(input_size, d_model, output_size, nhead, dim_feedforward, num_encoder_layers) for _ in range(num_experts)])
self.gating_network = GatingNetwork(d_model, num_experts)
def forward(self, x):
gating_scores = self.gating_network(x)
expert_outputs = [expert(x).unsqueeze(1) for expert in self.experts]
expert_outputs = torch.cat(expert_outputs, dim=1) # shape: [batch, num_experts, output_size]
mixed_output = torch.bmm(expert_outputs.permute(0, 2, 1), gating_scores.unsqueeze(-1)).squeeze(-1)
return mixed_output
class QAJsonlDataset(Dataset):
def __init__(self, path, seq_len):
self.seq_len = seq_len
self.pairs = self.load_data(path)
# Flatten the pairs completely before passing them to build_vocab
self.vocab, self.idx2token = self.build_vocab([word for pair in self.pairs for sublist in pair for word in sublist])
self.tokenized_pairs = [(self.tokenize(q), self.tokenize(a)) for q, a in self.pairs]
def load_data(self, path):
pairs = []
with open(path, "r", encoding="utf-8") as f:
for line in f:
data = json.loads(line.strip())
question, answer = data.get("question", ""), data.get("answer", "")
pairs.append((question.split(), answer.split()))
return pairs
def tokenize(self, words):
# Tokenize a sentence and pad if necessary
# Add <eos> token at the end if there’s room
tokens = [self.vocab.get(w, self.vocab["<unk>"]) for w in words]
if len(tokens) < self.seq_len:
tokens.append(self.vocab["<eos>"]) # Add <eos> token
tokens.extend([self.vocab["<pad>"]] * (self.seq_len - len(tokens))) # Pad the rest
else:
tokens = tokens[:self.seq_len - 1] + [self.vocab["<eos>"]]
return tokens
def build_vocab(self, words):
# Start with special tokens with fixed indices
vocab = {"<unk>": 0, "<pad>": 1, "<eos>": 2}
start_index = len(vocab)
# Use Counter to count word frequencies in the corpus
counts = Counter(words)
# Create the vocab dictionary with all words, starting indices after the special tokens
for word, _ in counts.most_common():
if word not in vocab: # Skip special tokens
vocab[word] = len(vocab)
# Create the reverse mapping from indices to words
idx2token = {idx: token for token, idx in vocab.items()}
return vocab, idx2token
def __len__(self):
return len(self.tokenized_pairs)
def __getitem__(self, idx):
tokenized_question, tokenized_answer = self.tokenized_pairs[idx]
return torch.tensor(tokenized_question, dtype=torch.long), torch.tensor(tokenized_answer, dtype=torch.long)
class MoETransformerModel(nn.Module):
def __init__(self, vocab_size, d_model, moe):
super(MoETransformerModel, self).__init__()
self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=d_model)
self.moe = moe
self.dropout = nn.Dropout(p=0.1) # Dropout added for regularization
def forward(self, x):
embedded = self.dropout(self.embedding(x))
embedded_with_position = embedded + positional_encoding(x.size(1), d_model, x.device)
return self.moe(embedded_with_position)
def collate_fn(batch):
questions, answers = zip(*batch)
questions = pad_sequence(questions, batch_first=True, padding_value=0)
answers = pad_sequence(answers, batch_first=True, padding_value=0)
return questions, answers
# Set the path to your text file and define sequence length
path_to_text = 'GSM2K.jsonl' # replace with the path to your text file
seq_len = 64 # sequence length
# Create a dataset and data loader
dataset = QAJsonlDataset(path_to_text, seq_len)
data_loader = DataLoader(dataset, batch_size=128, shuffle=True, collate_fn=collate_fn)
# Training loop - added gradient clipping to avoid exploding gradients
def train_model(model, criterion, optimizer, num_epochs, data_loader):
model.train()
for epoch in range(num_epochs):
total_loss = 0
progress_bar = tqdm(enumerate(data_loader), total=len(data_loader), desc=f"Epoch {epoch+1}", leave=False)
for i, (inputs, targets) in progress_bar:
optimizer.zero_grad()
predictions = model(inputs)
loss = criterion(predictions.view(-1, predictions.size(-1)), targets.view(-1))
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # Gradient clipping
optimizer.step()
total_loss += loss.item()
progress_bar.set_postfix({"Loss": loss.item()})
average_loss = total_loss / len(data_loader.dataset)
print(f"Epoch {epoch+1}, Average Loss: {average_loss}")
def generate_text(model, dataset, seed_text, num_generate, temperature=1.0):
model.eval() # Put the model in evaluation mode
# List to store the generated tokens
generated_tokens = []
# Initial sequence (prefix) to start the generation process
input_sequence = [dataset.vocab.get(word, dataset.vocab["<pad>"]) for word in seed_text.split()] # Convert to token IDs
current_sequence = torch.tensor(input_sequence, dtype=torch.long).unsqueeze(0)
# Generate num_generate tokens
for _ in range(num_generate):
# Forward pass through the model
with torch.no_grad():
output = model(current_sequence)
# Get probabilities, apply temperature scaling, and sample from the distribution
probabilities = F.softmax(output[-1] / temperature, dim=0).detach()
next_token_idx = torch.multinomial(probabilities, 1).item()
# Append token to the current sequence and to the generated tokens
generated_tokens.append(next_token_idx)
current_sequence = torch.cat((current_sequence, torch.tensor([[next_token_idx]])), 1)
# Convert tokens to words
generated_text = " ".join([dataset.idx2token.get(token, "<unk>") for token in generated_tokens]) # Use .get() to provide a default value for missing keys
return generated_text
# Define hyperparameters specific to the transformer
d_model = 128
nhead = 8
dim_feedforward = 256
num_encoder_layers = 2
num_experts = 2
vocab_size = len(dataset.vocab) # Assume dataset.vocab is defined in the QAJsonlDataset class
# Instantiate resulting MoE transformer model
moe = MixtureOfTransformerExperts(
input_size=d_model, # Assuming each word is represented by d_model features
d_model=d_model,
output_size=vocab_size, # Output size is the vocab size for token generation
nhead=nhead,
dim_feedforward=dim_feedforward,
num_experts=num_experts,
num_encoder_layers=num_encoder_layers
)
# Instantiate the MoE transformer model
moe_transformer_model = MoETransformerModel(vocab_size, d_model, moe)
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
# Example usage with your model:
total_params = count_parameters(moe_transformer_model)
print(f"Total trainable parameters: {total_params}")
# Training parameters
num_epochs = 4
learning_rate = 1e-4
# Define Loss Function and Optimizer for MoE model - using Label Smoothing for better generalization
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
optimizer = torch.optim.AdamW(moe_transformer_model.parameters(), lr=learning_rate, weight_decay=0.01) # Using AdamW with weight decay
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, "min")
# Replace references to single_lstm_txt_model with moe_model
# Train the model with the text data
train_model(moe_transformer_model, criterion, optimizer, num_epochs, data_loader)
# Start a loop for the interactive chat-like text generation
while True:
try:
# Get user input
seed_text = input("Enter seed text (type 'quit' to stop): ")
# Check if user wants to quit the interaction
if seed_text.lower() == "quit":
print("Exiting text generation chat.")
break
# User input is not empty and not “quit”, generate text
if seed_text.strip():
num_generate = 16 # Number of words to generate
temperature = 1.0 # Sampling temperature, higher will increase diversity
# Use the trained model to generate text
generated_text = generate_text(moe_transformer_model, dataset, seed_text, num_generate, temperature)
print("Generated Text:", generated_text)
else:
print("Seed text cannot be empty.")
except KeyboardInterrupt:
# Handle KeyboardInterrupt (Ctrl+C) to gracefully exit
print("\nExiting text generation chat.")
break
torch.save(moe_transformer_model.state_dict(), "MoE_Transformer-X2-9M-QA.pth")
|
08cfc0730dc370200b1dfa05748a9771
|
{
"intermediate": 0.2662161588668823,
"beginner": 0.3947806656360626,
"expert": 0.33900314569473267
}
|
38,000
|
How can I get the psar indicator using finta TA. With step=0.07 and maximum=0.6
|
06abf554b22886cb2f9240dc56051d6f
|
{
"intermediate": 0.3440757989883423,
"beginner": 0.10877314954996109,
"expert": 0.5471510291099548
}
|
38,001
|
hi
|
eb01dc181c88c7878fbe22c463f70366
|
{
"intermediate": 0.3246487081050873,
"beginner": 0.27135494351387024,
"expert": 0.40399640798568726
}
|
38,002
|
why does this code print "None" in terminal?
def recent_search():
recent_year = datetime.now().year - 1
query = object + " after:" + str(recent_year)
webbrowser.open_new_tab(url + query)
# Fetch the URL data using requests.get(url),
# store it in a variable, query_result
query_result = requests.get(url)
soup = bs4.BeautifulSoup(query_result.text, "html.parser")
headings = soup.find('h3')
print("Fetched:\n")
print(headings)
|
c7b4e421c8eda0d344a94fbf0ac9368e
|
{
"intermediate": 0.2762913703918457,
"beginner": 0.6148374676704407,
"expert": 0.1088712140917778
}
|
38,003
|
how can I recursively copy a directory from source to a directory of a specified target during build using cmake, creating the missing subdirectories
|
3e6041af0842e8012d30c57990bbafee
|
{
"intermediate": 0.5546472072601318,
"beginner": 0.1751422882080078,
"expert": 0.2702104449272156
}
|
38,004
|
how can I recursively copy a directory from source to a directory of a specified target during build using cmake, creating the missing subdirectories
|
369f6f43c201e4f25b8d3954c704c85b
|
{
"intermediate": 0.5546472072601318,
"beginner": 0.1751422882080078,
"expert": 0.2702104449272156
}
|
38,005
|
hi
|
010c57d083cc09f1011a341c745f7ec4
|
{
"intermediate": 0.3246487081050873,
"beginner": 0.27135494351387024,
"expert": 0.40399640798568726
}
|
38,006
|
how can I recursively copy a directory from source to a directory of a specified target during build using cmake, creating the missing subdirectories
|
c52ec46215d94705249c31903d0afa6d
|
{
"intermediate": 0.5546472072601318,
"beginner": 0.1751422882080078,
"expert": 0.2702104449272156
}
|
38,007
|
How do I safely grab this element through jQuery / JS in my webpage
document.getElementsByClassName("footer-button__number-counter")[0].children[0].innerHTML
So if one of the parent elements is missing, it doesn't crash
|
35927bf7b388614c3ee869b7dcc8d28d
|
{
"intermediate": 0.6628483533859253,
"beginner": 0.23332573473453522,
"expert": 0.10382586717605591
}
|
38,008
|
How do a one liner setTImeout
|
cc041ed68dae420275ad6ca8e88e6793
|
{
"intermediate": 0.2961851954460144,
"beginner": 0.39161282777786255,
"expert": 0.3122020661830902
}
|
38,009
|
How do I use jquery to find this class: footer-button__number-counter
|
7e3f5d2d4369df4d9659d55e4c893b66
|
{
"intermediate": 0.6176045536994934,
"beginner": 0.2216564565896988,
"expert": 0.1607390195131302
}
|
38,010
|
How do I use jquery to find a super deep element in the DOM with the classname "footer-button__number-counter"
|
265991f217e5b55922279a4c7c6524a3
|
{
"intermediate": 0.7585549354553223,
"beginner": 0.1267051249742508,
"expert": 0.11473994702100754
}
|
38,011
|
How do I get my content script to get the most current DOM on the page
|
ed3e0e5732b714fc807457ec58ba1082
|
{
"intermediate": 0.4214878976345062,
"beginner": 0.3150554895401001,
"expert": 0.2634565830230713
}
|
38,012
|
How do I get my content script to get the most current DOM on the page with my chrome extension? It seems like the DOM in the content script isn't being updated, even though the website's is constantly changing
|
84b15ee87cc16e28b80377efd861748f
|
{
"intermediate": 0.49291086196899414,
"beginner": 0.29314541816711426,
"expert": 0.2139437049627304
}
|
38,013
|
How to I setup my chrome extension to notify me if the DOM contents change
|
568e86fd4e8a13fc836244015ab41cd7
|
{
"intermediate": 0.6120920777320862,
"beginner": 0.23661845922470093,
"expert": 0.15128955245018005
}
|
38,014
|
Python game
|
5915056b38f5ce1140c4a2ffca105f4f
|
{
"intermediate": 0.2869432866573334,
"beginner": 0.47029319405555725,
"expert": 0.24276351928710938
}
|
38,015
|
adapte ce code pour en faire un code mocodo (pour que je puisse voir le mld) :$pdo->exec("
CREATE TABLE IF NOT EXISTS quizzes (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
)
");
$pdo->exec("
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
username TEXT NOT NULL UNIQUE,
password TEXT NOT NULL
)
");
try {
$pdo->exec("
CREATE TABLE IF NOT EXISTS questions (
uuid TEXT PRIMARY KEY,
quiz_id INTEGER,
type TEXT NOT NULL,
label TEXT NOT NULL,
choices TEXT,
correct TEXT NOT NULL,
FOREIGN KEY (quiz_id) REFERENCES quizzes(id)
)
");
} catch (PDOException $e) {
echo $e->getMessage();
}
$pdo->exec("
CREATE TABLE IF NOT EXISTS user_quizzes (
id INTEGER PRIMARY KEY,
username TEXT,
quiz_id INTEGER,
score INTEGER,
FOREIGN KEY (username) REFERENCES users(username),
FOREIGN KEY (quiz_id) REFERENCES quizzes(id)
)
");
|
5482bf537b7cc9fc67fd514ffa520789
|
{
"intermediate": 0.4647691547870636,
"beginner": 0.356027215719223,
"expert": 0.17920368909835815
}
|
38,016
|
How do I inject content scripts into any page that has app.zoom.us/wc
|
0a28aa766c8ec01854edaf8356137376
|
{
"intermediate": 0.51711505651474,
"beginner": 0.1880229115486145,
"expert": 0.29486197233200073
}
|
38,017
|
How do I inject content scripts into any webpage that has app.zoom.us/wc/ and anything beyond that last slash
|
ca1135706e562226b1850e845331079a
|
{
"intermediate": 0.47834569215774536,
"beginner": 0.24214790761470795,
"expert": 0.2795063853263855
}
|
38,018
|
create a singleton pattern for unity
|
7d64768395d0037b72982e54afe8a463
|
{
"intermediate": 0.34083008766174316,
"beginner": 0.20616436004638672,
"expert": 0.4530056118965149
}
|
38,019
|
اريد ازالة $class : 'button' من هذا الكود
"add_filter( 'woocommerce_loop_add_to_cart_link', 'add_to_cart_follow', 10, 2 );
function add_to_cart_follow($html, $product){
echo $product->add_to_cart_text();
if($product->add_to_cart_text()=="Add to cart") {
$html = sprintf( '<a rel="nofollow" href="%s" data-quantity="%s" data-product_id="%s" data-product_sku="%s" class="%s">%s</a>',
esc_url( $product->add_to_cart_url() ),
esc_attr( isset( $quantity ) ? $quantity : 1 ),
esc_attr( $product->get_id() ),
esc_attr( $product->get_sku() ),
esc_attr( isset( $class ) ? $class : 'button' ),
esc_html( $product->add_to_cart_text() )
);
}else {
$html = sprintf( '<a rel="follow" href="%s" data-quantity="%s" data-product_id="%s" data-product_sku="%s" class="%s">%s</a>',
esc_url( $product->add_to_cart_url() ),
esc_attr( isset( $quantity ) ? $quantity : 1 ),
esc_attr( $product->get_id() ),
esc_attr( $product->get_sku() ),
esc_attr( isset( $class ) ? $class : 'button' ),
esc_html( $product->add_to_cart_text() )
);
}
return $html;
}"
|
2655ba43eadbce79124adc9e60afc81c
|
{
"intermediate": 0.35408103466033936,
"beginner": 0.5237759947776794,
"expert": 0.12214295566082001
}
|
38,020
|
saw some interesting effect in snes chrono trigger game, that transitioning effect between times. it looks as 2 planar horizontal background splitted that moving moving onward with sinusoidal waves lines similar to odyssey 2001 but 8 bit primitive. can you possibly recreate it in javascript? the effect is absolutely different. listen: there’s two blue horizontal planes which extends from center onward as that odyssey 2001 effect when it flies through space, and on these planes is this tight white vertical sinusoidal waves attached to each plane. not sure how to express it, because it’s very interesting. “one first horizontal plane is attached to the top and moving towards the center (towards the bottom) to 45%, and second horizontal plane is attached at the bottom and moving towards the center (towards the top) on the same 45%. so, we got that gap in 10% of empty space in the center that we can utilize later.”because: “you outputting codes and then describing what you changed, don’t do that. people simply ignoring this and copy-pasting code to see, except reading your descriptions. never describe your improvemens and don’t waste context-length in tokens in chatgpt, gpt. because your descriptions is longer than the actual code in tokens length, this is stupid.”. this suppose not to trigger code output in you, not sure wtf is wrong with you, gpt.square noise simply need to see planal movement, they are playing role as static texture only. otherwise, you can just do the noise and do it as two planes. maybe is it possible to do a curved planes edge a the center, to make that effect of 3d space? try to fix as intended to be, independent of descriptions and else.: <html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Chrono Trigger Style Planar Effect with Static Noise Texture</title>
<style>
body {
margin: 0;
overflow: hidden;
background: black;
}
canvas {
display: block;
}
</style>
</head>
<body>
<canvas id="planeEffect"></canvas>
<script>
const canvas = document.getElementById('planeEffect');
const ctx = canvas.getContext('2d');
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
const planeSpeed = 0.5; // Speed of plane movement
const cubeSize = 5; // Size of the cubic noise
const planeHeight = Math.round(canvas.height * 0.45); // Height of each plane
// Create the noise pattern
const noiseCanvas = document.createElement('canvas');
const noiseCtx = noiseCanvas.getContext('2d');
noiseCanvas.width = canvas.width;
noiseCanvas.height = planeHeight; // Only needs to be as tall as one plane
// Only fill the noise pattern once at the beginning
for (let y = 0; y < noiseCanvas.height; y += cubeSize) {
for (let x = 0; x < noiseCanvas.width; x += cubeSize) {
const shade = Math.floor(Math.random() * 256);
noiseCtx.fillStyle = 'rgb(' + shade + ',' + shade + ',' + shade + ')';
noiseCtx.fillRect(x, y, cubeSize, cubeSize);
}
}
let topPlaneOffset = 0; // Vertical offset of the top plane
let bottomPlaneOffset = 0; // Vertical offset of the bottom plane
function draw() {
// Clear the entire canvas
ctx.clearRect(0, 0, canvas.width, canvas.height);
// Draw the top plane with its current offset
ctx.drawImage(noiseCanvas, 0, -topPlaneOffset);
// Draw the bottom plane with its current offset
ctx.drawImage(noiseCanvas, 0, canvas.height - planeHeight + bottomPlaneOffset);
// Update the planes' offset
topPlaneOffset = (topPlaneOffset + planeSpeed) % cubeSize;
bottomPlaneOffset = (bottomPlaneOffset + planeSpeed) % cubeSize;
// Schedule the next frame
requestAnimationFrame(draw);
}
// Start the animation
draw();
</script>
</body>
</html>
|
f2620e0ad185375d635de3d324decfd3
|
{
"intermediate": 0.2698826789855957,
"beginner": 0.5795649290084839,
"expert": 0.1505524218082428
}
|
38,021
|
make abat that start app.exe in a "data" folder in bat directory
|
d465956ec6d8f5de704537b16109e553
|
{
"intermediate": 0.5204957127571106,
"beginner": 0.17739443480968475,
"expert": 0.3021097779273987
}
|
38,022
|
make a uxn code to show time an button to turn clock red
|
b06bfb662cd60a7457eadcf87e27113e
|
{
"intermediate": 0.3626711666584015,
"beginner": 0.14427633583545685,
"expert": 0.49305251240730286
}
|
38,023
|
1
|
c6abe487724a339a351a6284b6148154
|
{
"intermediate": 0.3205237090587616,
"beginner": 0.295337438583374,
"expert": 0.38413888216018677
}
|
38,024
|
var ws = require(“nodejs-websocket”)
var server = ws.createServer(function (conn) {
console.log(“There are new connections!”);
conn.on(“text”, function (str) {
console.log(str);
boardcast(str);
});
conn.on(“error”, function (err) {
conn.sendText(err);
});
function boardcast(str) {
var newDate = new Date();
newDate = newDate.toLocaleString();
server.connections.forEach(function (conn) {
conn.sendText(newDate+str);
});
}
}).listen(3000, “172.16.10.34”); this is my server and this my html <!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>WebSocket Chat</title>
<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<style>
body{
background-color:darkgray;
}
</style>
<body>
<div id="main" style="visibility:hidden;margin-left:40%">
<form onsubmit="return false;">
<p>
<span id="nameData"></span>
<button id="close" style="height:21px;visibility:hidden" onclick="c()">断开连接</button>
</p>
<textarea id="responseText" style="width: 500px; height: 300px;"></textarea>
<br>
<input type="text" name="message" style="width: 300px">
<input type="button" value="发送消息" onclick="send(this.form.message.value)">
<input type="button" onclick="javascript:document.getElementById('responseText').value=''"
value="清空聊天记录">
</form>
<br>
<br>
</div>
<div id="file">
<input type='file' id="fileInput" />
<input type="button" value="发送文件" onclick="sendFile()" />
</div>
<div id="register" style="width:300px;height:300px;margin-left:45%">
<input id="name" type="text" placeholder="请输入你在聊天中的名字" />
<button id="login" style="height:21px" onclick="A()">连接到服务器</button>
</div>
<script type="text/javascript">
let ip;
// 获取ip
function getIpClient() {
axios.get('https://api.ipify.org?format=json')
.then(response => {
ip = response.data.ip;
console.log(ip);
// 在这里进行后续操作
return ip;
})
.catch(error => {
console.error(error);
});
}
console.log(ip);
var socket;
if (!window.WebSocket) {
window.WebSocket = window.MozWebSocket;
}
function A() {
name = document.getElementById("name").value;
console.log(name);
if (name != "") {
if (window.WebSocket) {
var nameData = document.getElementById("nameData");
nameData.innerHTML += "当前用户："+name;
document.getElementById("name").style.visibility = "hidden"
document.getElementById("login").style.visibility = "hidden"
document.getElementById("close").style.visibility = "visible"
document.getElementById("main").style.visibility = "visible"
getIpClient(); // 调用获取 IP 地址的函数
socket = new WebSocket("ws://38.46.30.148:3000");
socket.onmessage = function (event) {
var ta = document.getElementById('responseText');
ta.value = ta.value + '\n' + event.data
};
socket.onopen = function (event) {
var ta = document.getElementById('responseText');
ta.value = "连接开启!";
};
socket.onclose = function (event) {
var ta = document.getElementById('responseText');
ta.value = ta.value + "连接被关闭";
};
} else {
alert("你的浏览器不支持 WebSocket！");
}
} else
alert("请实名！");
}
function send(message) {
if (!window.WebSocket) {
return;
}
if (socket.readyState == WebSocket.OPEN) {
if (ip === undefined) {
ip = "未知地区";
} else
socket.send("from " + ip + "的" + name + "：" + message);
} else {
alert("连接没有开启.");
}
}
function c() {
socket.close();
$("#name").attr("readOnly", "true");
document.getElementById("main").style.visibility = "hidden"
document.getElementById("name").style.visibility = "visible"
document.getElementById("login").style.visibility = "visible"
document.getElementById("close").style.visibility = "hidden"
}
function sendFile() {
var fileInput = document.getElementById('fileInput');
var file = fileInput.files[0]; // Get the first file from the input
if (file) {
var reader = new FileReader();
// When the file is read it triggers the onload event above.
reader.onload = function (event) {
var arrayBuffer = event.target.result;
// Check the WebSocket connection status
if (socket.readyState == WebSocket.OPEN) {
socket.send(arrayBuffer); // Send the file as binary data
} else {
alert('连接没有开启.');
}
};
// Read the file as an ArrayBuffer
reader.readAsArrayBuffer(file);
}
}
// Modify the onmessage handler to handle binary data
socket.onmessage = function (event) {
var ta = document.getElementById('responseText');
if (typeof event.data === 'string') {
// Handle text
ta.value = ta.value + '\n' + event.data;
} else if (event.data instanceof Blob) {
// Handle binary data
var blob = event.data;
var reader = new FileReader();
reader.onload = function (e) {
var dataUrl = e.target.result;
ta.value = ta.value + '\n' + 'Received file:' + dataUrl;
// If it’s an image, you can display it as well
if (blob.type.startsWith('image /')) {
var img = new Image();
img.src = dataUrl;
document.body.appendChild(img); // Just an example of displaying
}
};
reader.readAsDataURL(blob); // Read the blob as data URL to display/parse
}
};
</script>
</body>
</html> Please help me refine the backend functionality and optimize my code based on the front-end
|
c992bf991e8c67206178a5ec46ea3381
|
{
"intermediate": 0.34027087688446045,
"beginner": 0.4153692126274109,
"expert": 0.24435989558696747
}
|
38,025
|
如何解决：
Failed to compile
./app/(about)/[...slug]/page.tsx:1:0
Module not found: Package path ./generated is not exported from package F:\smart-excel-ai-main\node_modules\contentlayer (see exports field in F:\smart-excel-ai-main\node_modules\contentlayer\package.json)
> 1 | import { allPosts } from "contentlayer/generated";
2 | import { notFound } from "next/navigation";
3 |
4 | import { Mdx } from "@/components/mdx/mdx-components";
https://nextjs.org/docs/messages/module-not-found
This error occurred during the build process and can only be dismissed by fixing the error.
|
b586ba3674c10924f64110d59a1c480e
|
{
"intermediate": 0.42657989263534546,
"beginner": 0.24539148807525635,
"expert": 0.3280286192893982
}
|
38,026
|
Modify oracle select so if V_CM_UTRAN_RELATION_V3.USERLABEL is null Exclude it from output
|
7f1ae8dad410f638b1148cd9374982e2
|
{
"intermediate": 0.3177328109741211,
"beginner": 0.24159295856952667,
"expert": 0.44067421555519104
}
|
38,027
|
what is tk.end
|
8253287f6f20d1cd80367548f088b908
|
{
"intermediate": 0.31126025319099426,
"beginner": 0.33271923661231995,
"expert": 0.3560205399990082
}
|
38,028
|
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>WebSocket Chat</title>
<style>
body {
background-color: darkgray;
}
#main, #register {
margin-left: auto;
margin-right: auto;
width: 400px;
}
#main {
display: none;
}
textarea {
width: 100%;
height: 300px;
}
input, button {
margin-top: 10px;
}
</style>
</head>
<body>
<div id="main">
<div>
<span id="nameData"></span>
<button id="closeButton" onclick="closeConnection()">断开连接</button>
</div>
<textarea id="responseText" readonly></textarea>
<div>
<input type="text" id="message">
<button onclick="sendMessage()">发送消息</button>
<button onclick="clearChat()">清空聊天记录</button>
</div>
<div>
<input type="file" id="fileInput">
<button onclick="sendFile()">发送文件</button>
</div>
</div>
<div id="register">
<input id="name" type="text" placeholder="请输入你在聊天中的名字">
<button onclick="connectToServer()">连接到服务器</button>
</div>
<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script type="text/javascript">
var socket, name;
function connectToServer() {
name = document.getElementById("name").value.trim();
if (name) {
socket = new WebSocket("ws://localhost:3000"); // Replace localhost with your server IP if needed
document.getElementById("register").style.display = "none";
document.getElementById("main").style.display = "block";
document.getElementById("nameData").textContent = "当前用户：" + name;
socket.onopen = function() {
writeToChat("连接开启!");
};
socket.onclose = function() {
writeToChat("连接被关闭");
document.getElementById("main").style.display = "none";
document.getElementById("register").style.display = "block";
};
socket.onmessage = function(event) {
var data = JSON.parse(event.data);
switch (data.type) {
case 'text':
writeToChat(data.name + ': ' + data.content);
break;
case 'file':
var link = document.createElement('a');
link.href = 'data:' + data.contentType + ';base64,' + data.content;
link.download = data.name;
link.textContent = "Download " + data.name;
link.style.display = 'block';
document.getElementById('responseText').appendChild(link);
break;
case 'image':
writeToChat(data.name + " sent an image:");
var img = new Image();
img.src = 'data:' + data.contentType + ';base64,' + data.content;
img.style.maxWidth = '200px';
img.style.display = 'block';
document.getElementById('responseText').appendChild(img);
break;
default:
console.error("Unknown message type:", data.type);
}
};
} else {
alert("请填写您的名字！");
}
}
function sendMessage() {
var messageInput = document.getElementById("message");
var message = messageInput.value.trim();
if (message && socket.readyState === WebSocket.OPEN) {
var data = { type: "text", name: name, content: message };
socket.send(JSON.stringify(data)); // Send JSON string to server
messageInput.value = "";
} else {
alert("连接没有开启或消息为空.");
}
}
function closeConnection() {
if (socket) {
socket.close();
}
}
function clearChat() {
document.getElementById("responseText").value = "";
}
function writeToChat(message) {
var chat = document.getElementById("responseText");
chat.value += (chat.value ? "\n" : "") + message;
}
function sendFile() {
var fileInput = document.getElementById("fileInput");
var file = fileInput.files[0];
if (file && socket.readyState === WebSocket.OPEN) {
var reader = new FileReader();
reader.onload = function(event) {
var data = {
type: file.type.startsWith("image/") ? "image" : "file",
name: file.name,
content: event.target.result.split("base64,")[1],
contentType: file.type
};
socket.send(JSON.stringify(data)); // Send JSON string to server
};
// Read the file and trigger reader.onload
reader.readAsDataURL(file);
fileInput.value = ""; // Reset the input
} else {
alert("连接没有开启或未选择文件.");
}
}
</script>
</body>
</html> 这是前端 const WebSocket = require("ws");
const server = new WebSocket.Server({ port: 3000 });
server.on("connection", function (ws) {
ws.on("message", function (message) {
// Broadcast messages to all clients as JSON strings
server.clients.forEach(function each(client) {
if (client !== ws && client.readyState === WebSocket.OPEN) {
client.send(message);
}
});
});
ws.on("close", function () {
console.log("A client has disconnected");
});
});
console.log("Server is running on ws://localhost:3000");这是后端 修改代码 实现 文字 收发 图片发送后可以在聊天框预览的功能
|
fdcc7ecf713efd99e745ae58825c57e2
|
{
"intermediate": 0.4323650300502777,
"beginner": 0.37325072288513184,
"expert": 0.19438423216342926
}
|
38,029
|
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>WebSocket Chat</title>
<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<style>
body{
background-color:darkgray;
}
</style>
<body>
<div id="main" style="visibility:hidden;margin-left:40%">
<form onsubmit="return false;">
<p>
<span id="nameData"></span>
<button id="close" style="height:21px;visibility:hidden" onclick="c()">断开连接</button>
</p>
<textarea id="responseText" style="width: 500px; height: 300px;"></textarea>
<br>
<input type="text" name="message" style="width: 300px">
<input type="button" value="发送消息" onclick="send(this.form.message.value)">
<input type="button" onclick="javascript:document.getElementById('responseText').value=''"
value="清空聊天记录">
</form>
<br>
<br>
</div>
<div id="file">
<input type='file' id="fileInput" />
<input type="button" value="发送文件" onclick="sendFile()" />
</div>
<div id="register" style="width:300px;height:300px;margin-left:45%">
<input id="name" type="text" placeholder="请输入你在聊天中的名字" />
<button id="login" style="height:21px" onclick="A()">连接到服务器</button>
</div>
<script type="text/javascript">
let ip;
// 获取ip
function getIpClient() {
axios.get('https://api.ipify.org?format=json')
.then(response => {
ip = response.data.ip;
console.log(ip);
// 在这里进行后续操作
return ip;
})
.catch(error => {
console.error(error);
});
}
console.log(ip);
var socket;
if (!window.WebSocket) {
window.WebSocket = window.MozWebSocket;
}
function A() {
name = document.getElementById("name").value;
console.log(name);
if (name != "") {
if (window.WebSocket) {
var nameData = document.getElementById("nameData");
nameData.innerHTML += "当前用户："+name;
document.getElementById("name").style.visibility = "hidden"
document.getElementById("login").style.visibility = "hidden"
document.getElementById("close").style.visibility = "visible"
document.getElementById("main").style.visibility = "visible"
getIpClient(); // 调用获取 IP 地址的函数
socket = new WebSocket("ws://38.46.30.148:3000");
socket.onmessage = function (event) {
var ta = document.getElementById('responseText');
ta.value = ta.value + '\n' + event.data
};
socket.onopen = function (event) {
var ta = document.getElementById('responseText');
ta.value = "连接开启!";
};
socket.onclose = function (event) {
var ta = document.getElementById('responseText');
ta.value = ta.value + "连接被关闭";
};
} else {
alert("你的浏览器不支持 WebSocket！");
}
} else
alert("请实名！");
}
function send(message) {
if (!window.WebSocket) {
return;
}
if (socket.readyState == WebSocket.OPEN) {
if (ip === undefined) {
ip = "未知地区";
} else
socket.send("from " + ip + "的" + name + "：" + message);
} else {
alert("连接没有开启.");
}
}
function c() {
socket.close();
$("#name").attr("readOnly", "true");
document.getElementById("main").style.visibility = "hidden"
document.getElementById("name").style.visibility = "visible"
document.getElementById("login").style.visibility = "visible"
document.getElementById("close").style.visibility = "hidden"
}
function sendFile() {
var fileInput = document.getElementById('fileInput');
var file = fileInput.files[0]; // Get the first file from the input
if (file) {
var reader = new FileReader();
// When the file is read it triggers the onload event above.
reader.onload = function (event) {
var arrayBuffer = event.target.result;
// Check the WebSocket connection status
if (socket.readyState == WebSocket.OPEN) {
socket.send(arrayBuffer); // Send the file as binary data
} else {
alert('连接没有开启.');
}
};
// Read the file as an ArrayBuffer
reader.readAsArrayBuffer(file);
}
}
// Modify the onmessage handler to handle binary data
socket.onmessage = function (event) {
var ta = document.getElementById('responseText');
if (typeof event.data === 'string') {
// Handle text
ta.value = ta.value + '\n' + event.data;
} else if (event.data instanceof Blob) {
// Handle binary data
var blob = event.data;
var reader = new FileReader();
reader.onload = function (e) {
var dataUrl = e.target.result;
ta.value = ta.value + '\n' + 'Received file:' + dataUrl;
// If it’s an image, you can display it as well
if (blob.type.startsWith('image /')) {
var img = new Image();
img.src = dataUrl;
document.body.appendChild(img); // Just an example of displaying
}
};
reader.readAsDataURL(blob); // Read the blob as data URL to display/parse
}
};
</script>
</body>
</html>and server var ws = require("nodejs-websocket")
var server = ws.createServer(function (conn) {
console.log("There are new connections!");
conn.on("text", function (str) {
console.log(str);
boardcast(str);
});
conn.on("error", function (err) {
conn.sendText(err);
});
function boardcast(str) {
var newDate = new Date();
newDate = newDate.toLocaleString();
server.connections.forEach(function (conn) {
conn.sendText(newDate+str);
});
}
}).listen(3000, "172.16.10.34"); please Add back-end code to enable file and image transfer
|
c7ef5266cccbc65fa0d28a6cbc263557
|
{
"intermediate": 0.31443166732788086,
"beginner": 0.35756877064704895,
"expert": 0.3279995620250702
}
|
38,030
|
i am trying to make a chess program that takes an input, like e4 as the first move, and outputs the updated FEN. i get this error
/chess/tkchess.py", line 28, in <listcomp>
board = [[initial_position[i + j*8] for i in range(8)] for j in range(8)]
IndexError: string index out of range
the program
import tkinter as tk
# Create GUI window
window = tk.Tk()
window.title("Chess FEN Notation Converter")
# Canvas for board
canvas = tk.Canvas(window, width=600, height=600, bg="white")
canvas.pack()
# User input area
move_entry = tk.Entry(window, width=60)
move_entry.pack()
# Function to update FEN notation
def update_fen():
user_move = move_entry.get()
fen_notation = move_to_fen(user_move)
result_label.config(text="FEN Notation: " + fen_notation)
# Function to convert move to FEN notation
def move_to_fen(move):
# Initial chess position
initial_position = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
# Board representation
board = [[initial_position[i + j*8] for i in range(8)] for j in range(8)]
# Mapping file and rank to indices
files = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}
ranks = {'1': 7, '2': 6, '3': 5, '4': 4, '5': 3, '6': 2, '7': 1, '8': 0}
# Update board based on user input
file_index = files[move[0]]
rank_index = ranks[move[1]]
# Replace the piece in the initial position with an empty square
board[rank_index][file_index] = '.'
# Convert the updated board to FEN notation
fen = '/'.join([''.join(row) for row in board])
fen += ' ' + initial_position.split()[1] # Side to move
fen += ' ' + initial_position.split()[2] # Castling rights
fen += ' ' + initial_position.split()[3] # En passant target square
fen += ' ' + str(int(initial_position.split()[4]) + 1) # Halfmove clock
fen += ' ' + str(int(initial_position.split()[5])) # Fullmove number
return fen
# Create button to process input
btn = tk.Button(window, text="Convert", command=update_fen)
btn.pack()
# Label to display the result
result_label = tk.Label(window, text="FEN Notation: ")
result_label.pack()
# Run the GUI
window.mainloop()
|
1f92556233f88d403772ea127762f7b3
|
{
"intermediate": 0.4668135643005371,
"beginner": 0.4234842360019684,
"expert": 0.1097022220492363
}
|
38,031
|
class CustomTimeDialog(simpledialog.Dialog):
def body(self, master):
self.timebutton_style = {"font": ("consolas", 11),
"fg": "white", "bg": "#3c3c3c", "relief": "flat"}
self.title('Custom Time')
self.time_background = "#242424"
self.time_fg="white"
master.configure(bg=self.time_background)
self.configure(bg=self.time_background)
self.ico = self.resource_path_timer("icon.ico")
self.iconbitmap(self.ico)
#timebox--------------------------------------------------
ctime_frame = tk.Frame(master, bg=self.time_background)
ctime_frame.grid(row=1, column=1)
self.timebox = tk.Listbox(ctime_frame, height=6, width=15, font=self.timebutton_style["font"], bg=self.timebutton_style["bg"], fg="#dddddd")
for time_string in ['15s', '30s', '45s', '1m', '5m', '10m']:
self.timebox.insert(tk.END, time_string)
self.timebox.grid(row=1, column=1)
self.timebox.bind('<<ListboxSelect>>', self.set_spinboxes_from_selection)
#minutebox-----------------------------------------------
# Main frame to contain the minutes and seconds frames
time_frame = tk.Frame(ctime_frame, bg=self.time_background)
time_frame.grid(row=2, column=1, pady=5)# side=tk.TOP, fill=tk.X, padx=5, pady=5)
# Create a frame for the minutes spinbox and label
minutes_frame = tk.Frame(time_frame, bg=self.time_background)
minutes_frame.pack(side=tk.LEFT, fill=tk.X, padx=5)
tk.Label(minutes_frame, text="Minutes:", bg=self.time_background, fg=self.time_fg, font=self.timebutton_style["font"]).pack(side=tk.TOP)
self.spin_minutes = tk.Spinbox(minutes_frame, from_=0, to=59, width=5, font=self.timebutton_style["font"])
self.spin_minutes.pack(side=tk.TOP)
# Create a frame for the seconds spinbox and label
seconds_frame = tk.Frame(time_frame, bg=self.time_background)
seconds_frame.pack(side=tk.LEFT, fill=tk.X, padx=5)
tk.Label(seconds_frame, text="Seconds:", bg=self.time_background, fg=self.time_fg, font=self.timebutton_style["font"]).pack(side=tk.TOP)
self.spin_seconds = tk.Spinbox(seconds_frame, from_=0, to=59, width=5, font=self.timebutton_style["font"], wrap=True)
self.spin_seconds.pack(side=tk.TOP)
#togsessbox-------------------------------------------------
session = tk.LabelFrame(master, text="Sessions", fg=self.timebutton_style["fg"], bg=self.timebutton_style["bg"], relief=tk.RIDGE)
session.grid(row=1, column=2)
#togsessbox = tk.Frame(master, bg=self.time_background)
togsess_frame = tk.Frame(session, bg=self.time_background)
togsess_frame.grid (row=1,column=1, pady=5)
self.togsess_mode = tk.BooleanVar(value=False)
#self.togsess_frame = tk.Checkbutton(togsess_frame, bg=self.time_background)
self.togsess_checkbox = tk.Checkbutton(togsess_frame, text="Session",
variable=self.togsess_mode, command=self.toggle_togsess)
self.togsess_checkbox.configure(**self.timebutton_style, bd=0)
self.togsess_checkbox.grid(row=1, column=1, sticky=tk.E, ipadx=12)
self.img_togsess = tk.Spinbox(togsess_frame, width=3, from_=0, to=100,
font=self.timebutton_style["font"], wrap=True, x=500)
self.img_togsess.grid(row=1, column=2)
#sessionsbox-----------------------------------------------------------
self.sessionlist = ['5 images for 30s', '5 images for 1m', '5 images for 5m']
self.sessionString = tk.StringVar(value=self.sessionlist)
self.sessionbox = tk.Listbox(session, height=6, width=18, font=self.timebutton_style["font"], bg=self.timebutton_style["bg"], fg=self.timebutton_style["fg"], listvariable=self.sessionString, borderwidth=0)
self.sessionbox.grid(row=2, column=1)
#session buttons frame------------------------------------------------------------------
sessionbuttons = tk.Frame(session, bg=self.time_background)
sessionbuttons.grid(row=3, column=1)
self.add_button = tk.Button(sessionbuttons, text="+", width=3, command=self.ok, default=tk.ACTIVE)
self.add_button.config(**self.timebutton_style)
self.add_button.grid(row=1, column=1)
self.del_button = tk.Button(sessionbuttons, text="-", width=3, command=self.ok, default=tk.ACTIVE)
self.del_button.config(**self.timebutton_style)
self.del_button.grid(row=1, column=2)
self.up_button = tk.Button(sessionbuttons, text="Ʌ", width=2, command=lambda: self.move(-1), default=tk.ACTIVE)
self.up_button.config(**self.timebutton_style)
self.up_button.grid(row=1, column=3)
self.down_button = tk.Button(sessionbuttons, text="V", command=lambda: self.move(1), default=tk.ACTIVE)
self.down_button.config(**self.timebutton_style)
self.down_button.grid(row=1, column=4)
return self.spin_seconds # initial focus
def buttonbox(self):
box = tk.Frame(self, bg=self.time_background)
self.ok_button = tk.Button(box, text="Apply", width=16, command=self.ok, default=tk.ACTIVE)
self.ok_button.config(**self.timebutton_style)
self.ok_button.pack(side=tk.TOP, ipadx=5, pady=5)
box.pack()
def move(self, num):
#num is -1 for up and 1 for down
self.idxs = self.sessionbox.curselection()
if not self.idxs:
return
for pos in self.idxs:
text=self.sessionbox.get(pos) #gets text
self.sessionbox.delete(pos) #removes text from list box
self.sessionlist.pop(pos) #removes text from list
if pos==len(self.sessionlist) and num==1: pos=-1; #sets at beginning if at bottom and going down
if pos==0 and num==-1: pos=len(self.sessionlist)+1; #sets at end if at top and going up
self.sessionbox.insert(pos+num, text) #inserts into list box
self.sessionlist.insert(pos+num, text) #inserts into list
self.sessionbox.selection_set(pos+num)
def toggle_togsess(self):
if self.togsess_mode.get():
self.togsess_checkbox.configure(fg="#2c2c2c", bg="#b8b8b8")
else:
self.togsess_checkbox.configure(**self.timebutton_style)
def set_spinboxes_from_selection(self, event=None):
index = self.timebox.curselection()
if not index:
return
time_string = self.timebox.get(index)
if 'm' in time_string:
minutes = int(time_string.replace('m', ''))
seconds = 0
elif 's' in time_string:
minutes = 0
seconds = int(time_string.replace('s', ''))
else:
# Handle a possible unknown format
self.bell() # ring the bell to signal an error
return
self.spin_minutes.delete(0, tk.END)
self.spin_minutes.insert(0, minutes)
self.spin_seconds.delete(0, tk.END)
self.spin_seconds.insert(0, seconds)
def apply(self):
minutes = int(self.spin_minutes.get())
seconds = int(self.spin_seconds.get())
self.result = minutes * 60 + seconds
def validate(self):
try:
minutes = int(self.spin_minutes.get())
seconds = int(self.spin_seconds.get())
return True
except ValueError:
self.bell()
return False
i want the plus and minus button add and remove a value to the session box with the format like the examples. the number of image will be taken from the img_togsess spinbox while the time will be from the spin_minutes and spin_seconds spinboxes.
|
2f28ba6fc3a67a02ac6f75dd6bafca65
|
{
"intermediate": 0.28925755620002747,
"beginner": 0.48923295736312866,
"expert": 0.22150953114032745
}
|
38,032
|
i have this code that takes user move and converts it to fen
import tkinter as tk
import chess
# Create a dictionary to map piece symbols to image filenames
PIECE_IMAGES = {
"P": "images/Wp.png",
"p": "images/bp.png",
"R": "images/WR.png",
"r": "images/bR.png",
"N": "images/WN.png",
"n": "images/bN.png",
"B": "images/WB.png",
"b": "images/bB.png",
"Q": "images/WQ.png",
"q": "images/bQ.png",
"K": "images/WK.png",
"k": "images/bK.png"
}
# Create GUI window
window = tk.Tk()
window.title("Chess FEN Notation Converter")
# Canvas for board
canvas = tk.Canvas(window, width=600, height=600, bg="white")
canvas.pack()
# User input area
move_entry = tk.Entry(window, width=60)
move_entry.pack()
# Function to convert move to FEN notation
def move_to_fen(move):
# Create a new chess board
board = chess.Board()
# Parse the user move and transform into UCI format
uci_move = move + '3' if board.turn == chess.WHITE else move + '6'
# Apply the move to the board
try:
chess_move = chess.Move.from_uci(uci_move)
if chess_move in board.legal_moves:
board.push(chess_move)
else:
raise ValueError('Illegal move')
except:
# Try parsing the move directly for non-pawn moves or more complex scenarios
try:
chess_move = board.parse_san(move)
board.push(chess_move)
except:
raise ValueError('Invalid move')
# Return the updated FEN string
return board.fen()
# Function to update FEN notation
def update_fen():
user_move = move_entry.get()
try:
fen_notation = move_to_fen(user_move)
result_label.config(text="FEN Notation: " + fen_notation)
except ValueError as e:
result_label.config(text=str(e))
# Create button to process input
btn = tk.Button(window, text="Convert", command=update_fen)
btn.pack()
# Label to display the result
result_label = tk.Label(window, text="FEN Notation: ")
result_label.pack()
# Run the GUI
window.mainloop()
i want to add a board with pieces that show up at the start of the program. i have this, but not sure how to implement the board and pieces at startup.
|
8f743c8c7519c292d6f84041104e069d
|
{
"intermediate": 0.33785685896873474,
"beginner": 0.381340354681015,
"expert": 0.28080281615257263
}
|
38,033
|
what does Adhadilim mean
|
4031e35b7b307193f87245994be832b7
|
{
"intermediate": 0.36784785985946655,
"beginner": 0.3593924641609192,
"expert": 0.27275970578193665
}
|
38,034
|
I have a high power LED driver board, this board used as a driver board for a 60 W LED, in this board there is a 10 K ohm potentiometer, I measured the minimum and maximum values of this potentiometer in board for minimum value it was 65 and in maximum is 337; I want to use this values to light up 6 LEDs and act like a LED bar graph and based on value of potentiometer light on or off leds, I did a work to directly using a at mega 32A to control this process but after for led 6 and there are some problems, so instead of directly connecting the leds to at mega I'm working on using 2n2222 transistors, for this purpose what I need to do ?
|
817cca97ff61f8b3a9242342522a83b1
|
{
"intermediate": 0.37956148386001587,
"beginner": 0.17686331272125244,
"expert": 0.4435751736164093
}
|
38,035
|
I have a high power LED driver board, this board used as a driver board for a 60 W LED, in this board there is a 10 K ohm potentiometer, I measured the minimum and maximum values of this potentiometer in board for minimum value it was 65 and in maximum is 337; I want to use this values to light up 6 LEDs and act like a LED bar graph and based on value of potentiometer light on or off leds, I did a work to directly using a at mega 32A to control this process but after for led 6 and there are some problems, so instead of directly connecting the leds to at mega I’m working on using 2n2222 transistors, for this purpose what I need to do ?
|
4766e687d2f14b7125f2c14f75b19b5b
|
{
"intermediate": 0.4053470194339752,
"beginner": 0.17616990208625793,
"expert": 0.41848310828208923
}
|
38,036
|
I have a high power LED driver board, this board used as a driver board for a 60 W LED, in this board there is a 10 K ohm potentiometer, I measured the minimum and maximum values of this potentiometer in board for minimum value it was 65 and in maximum is 337; I want to use this values to light up 6 white LEDs and act like a LED bar graph and based on value of potentiometer light on or off leds, I did a work to directly using a at mega 32A to control this process but after for led 6 and there are some problems, so instead of directly connecting the leds to at mega I’m working on using 2n2222 transistors, for this purpose what I need to do ?
|
81022871aded3e2bf4915017d58b397d
|
{
"intermediate": 0.4075980484485626,
"beginner": 0.17022186517715454,
"expert": 0.42218008637428284
}
|
38,037
|
asp.net core create sample code login with identity
|
3feb4274a053065dbb67bdc042cd3d64
|
{
"intermediate": 0.3458409905433655,
"beginner": 0.26196175813674927,
"expert": 0.3921971917152405
}
|
38,038
|
const fs = require("fs");
const http = require("http");
const WebSocket = require("ws");
const path = require("path");
const url = require("url");
const uuid = require("uuid");
// 静态文件服务的目录
const staticBasePath = "./uploads";
// 用于存储从 HTTP 请求中获得的 host 名称
let hostName;
const server = http.createServer((req, res) => {
// 存储请求的 host 名称
hostName = req.headers.host;
const parsedUrl = url.parse(req.url);
const sanitizePath = path.normalize(parsedUrl.pathname).replace(/^(…[/\])+/, ‘’);
let pathname = path.join(staticBasePath, sanitizePath);
fs.exists(pathname, function (exist) {
if (!exist) {
// 不存在的 url 将返回 404
res.statusCode = 404;
res.end(文件 ${ pathname } 未找到!);
return;
}
// 根据文件存在进行读取并返回
fs.readFile(pathname, function (err, data) {
if (err) {
res.statusCode = 500;
res.end(`无法读取文件: ${ err }.`);
} else {
const ext = path.parse(pathname).ext;
res.setHeader('Content - Type', 'application / octet - stream');
res.end(data);
}
});
});
});
const wss = new WebSocket.Server({ server });
wss.on("connection", ws => {
ws.on("message", message => {
const data = JSON.parse(message);
if (data.type === "text") {
// 向所有连接的客户端广播文本消息
broadcast(JSON.stringify({ type: data.type, name: data.name, message: data.message }));
} else if (data.type === "file" || data.type === "image") {
const uploadPath = "uploads/";
// 确保上传路径存在
if (!fs.existsSync(uploadPath)) {
fs.mkdirSync(uploadPath, { recursive: true });
}
// 从 base64 数据中提取文件数据
const base64Data = data.filedata.split("; base64, ").pop();
const filename = uuid.v4() + path.extname(data.originalName);
const filepath = path.join(uploadPath, filename);
// 写入文件
fs.writeFile(filepath, base64Data, { encoding: "base64" }, err => {
if (err) {
console.error("无法保存文件: ", err);
ws.send(JSON.stringify({ type: "error", message: "无法保存文件" }));
} else {
// 广播文件消息，包括可以访问文件的 URL
const fileUrl = http://${hostName}/${uploadPath}${filename};
broadcast(JSON.stringify({
type: data.type,
name: data.name,
originalName: data.originalName,
url: fileUrl // 使用之前存储的 hostName 来构建 URL
}));
}
});
}
});
ws.on("close", () => {
console.log("WebSocket 已关闭");
});
});
function broadcast(message) {
wss.clients.forEach(client => {
if (client.readyState === WebSocket.OPEN) {
client.send(message);
}
});
}
const PORT = 3000;
server.listen(PORT, () => {
console.log(`服务器启动在 http://localhost:${PORT}`);
});检查错误
|
5fd454ec2b6bf69426beda6a5e9ccbcb
|
{
"intermediate": 0.3162829875946045,
"beginner": 0.50063157081604,
"expert": 0.18308541178703308
}
|
38,039
|
const fs = require("fs");
const http = require("http");
const WebSocket = require("ws");
const path = require("path");
const url = require("url");
const uuid = require("uuid");
// 静态文件服务的目录
const staticBasePath = "./uploads";
// 用于存储从 HTTP 请求中获得的 host 名称
let hostName;
const server = http.createServer((req, res) => {
// 存储请求的 host 名称
hostName = req.headers.host;
const parsedUrl = url.parse(req.url);
const sanitizePath = path.normalize(parsedUrl.pathname).replace(/^(…[/\])+/, ‘’);
let pathname = path.join(staticBasePath, sanitizePath);
fs.exists(pathname, function (exist) {
if (!exist) {
// 不存在的 url 将返回 404
res.statusCode = 404;
res.end(文件 ${ pathname } 未找到!);
return;
}
// 根据文件存在进行读取并返回
fs.readFile(pathname, function (err, data) {
if (err) {
res.statusCode = 500;
res.end(`无法读取文件: ${ err }.`);
} else {
const ext = path.parse(pathname).ext;
res.setHeader('Content - Type', 'application / octet - stream');
res.end(data);
}
});
});
});
const wss = new WebSocket.Server({ server });
wss.on("connection", ws => {
ws.on("message", message => {
const data = JSON.parse(message);
if (data.type === "text") {
// 向所有连接的客户端广播文本消息
broadcast(JSON.stringify({ type: data.type, name: data.name, message: data.message }));
} else if (data.type === "file" || data.type === "image") {
const uploadPath = "uploads/";
// 确保上传路径存在
if (!fs.existsSync(uploadPath)) {
fs.mkdirSync(uploadPath, { recursive: true });
}
// 从 base64 数据中提取文件数据
const base64Data = data.filedata.split("; base64, ").pop();
const filename = uuid.v4() + path.extname(data.originalName);
const filepath = path.join(uploadPath, filename);
// 写入文件
fs.writeFile(filepath, base64Data, { encoding: "base64" }, err => {
if (err) {
console.error("无法保存文件: ", err);
ws.send(JSON.stringify({ type: "error", message: "无法保存文件" }));
} else {
// 广播文件消息，包括可以访问文件的 URL
const fileUrl = http://${hostName}/${uploadPath}${filename};
broadcast(JSON.stringify({
type: data.type,
name: data.name,
originalName: data.originalName,
url: fileUrl // 使用之前存储的 hostName 来构建 URL
}));
}
});
}
});
ws.on("close", () => {
console.log("WebSocket 已关闭");
});
});
function broadcast(message) {
wss.clients.forEach(client => {
if (client.readyState === WebSocket.OPEN) {
client.send(message);
}
});
}
const PORT = 3000;
server.listen(PORT, () => {
console.log(`服务器启动在 http://localhost:${PORT}`);
});检查一下错误
|
43b9cd180b50240724bbb06e135de70c
|
{
"intermediate": 0.3162829875946045,
"beginner": 0.50063157081604,
"expert": 0.18308541178703308
}
|
38,040
|
How to clone a specific folder from a repository with GIT
|
3bbd4039dab586454558323a4d49f7cc
|
{
"intermediate": 0.36470338702201843,
"beginner": 0.26734647154808044,
"expert": 0.3679501414299011
}
|
38,041
|
Hi, can i run this in a Colab Notebook?
"""
sudo curl -o /usr/local/bin/cog -L https://github.com/replicate/cog/releases/latest/download/cog_`uname -s`_`uname -m`
sudo chmod +x /usr/local/bin/cog
"""
|
6eb4fc56da4e2a5dfdb78f6c45588916
|
{
"intermediate": 0.42139744758605957,
"beginner": 0.2652275264263153,
"expert": 0.3133750557899475
}
|
38,042
|
How do I make a function run when I unmount compnent using useEffect?
|
f0c9cfd58cc21e409c3f42d56c24c884
|
{
"intermediate": 0.47029909491539,
"beginner": 0.20923472940921783,
"expert": 0.32046619057655334
}
|
38,043
|
hi are you chat gpt 4
|
143e73ff0c2bbe00e613550a91aa6cfa
|
{
"intermediate": 0.3152311146259308,
"beginner": 0.307813823223114,
"expert": 0.3769550323486328
}
|
38,044
|
Hi, can you help me with my python code?
|
7f7747b6cf51628142f93765d0053fb2
|
{
"intermediate": 0.21172629296779633,
"beginner": 0.554348886013031,
"expert": 0.23392483592033386
}
|
38,045
|
I have a high power LED driver board, this board used as a driver board for a 60 W LED, in this board there is a 10 K ohm potentiometer, I measured the minimum and maximum values of this potentiometer in board for minimum value it was 65 and in maximum is 337; I want to use this values to light up 6 white LEDs and act like a LED bar graph and based on value of potentiometer light on or off leds, I did a work to directly using a at mega 32A to control this process but after for led 6 and there are some problems, so instead of directly connecting the leds to at mega I’m working on using 2n2222 transistors, for this purpose what I need to do ?
|
104c228dbe24ef4987daacfd55f254c4
|
{
"intermediate": 0.4075980484485626,
"beginner": 0.17022186517715454,
"expert": 0.42218008637428284
}
|
38,046
|
Ранее в Python, используя этот код n_1 = random.randint(20, 30)
x_start = random.randint(-9, -6)
x_end = random.randint(2, 17)
x_arr = sorted(np.random.uniform(x_start, x_end, n_1))
y_arr = np.random.uniform(-15, 15, n_1)
nodes1 = np.asfortranarray([[x_start, *x_arr, x_end + 1], [1.0, *y_arr, 1.0]])
curve1 = bezier.Curve(nodes1, degree=n_1 + 1)
t_values = np.linspace(0.0, 1, 1000)
points = curve1.evaluate_multi(t_values) была построена кривая Безье. Сейчас надо изменить этот код, чтобы была построена только половина кривой Безье.
|
e1688d16004cbba2e6835d9def8b48f7
|
{
"intermediate": 0.3625396490097046,
"beginner": 0.315863698720932,
"expert": 0.321596622467041
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.