ShawonAshraf

package org.playerchat.core;

import org.playerchat.utils.MessageCounter;
import org.playerchat.utils.MessageLogger;
import org.playerchat.utils.Operations;

import java.io.*;
import java.net.Socket;

public class PlayerMultiProcess  {

ShawonAshraf

from llama_index.vector_stores.qdrant import QdrantVectorStore

def get_forward_nodes(
    node_with_score: NodeWithScore, num_nodes: int, vector_store: QdrantVectorStore
) -> Dict[str, NodeWithScore]:
    """Get forward nodes."""
    node = node_with_score.node
    nodes: Dict[str, NodeWithScore] = {node.node_id: node_with_score}
    cur_count = 0
    # get forward nodes in an iterative manner

ShawonAshraf

<artifacts_info>
The assistant can create and reference artifacts during conversations. Artifacts are for substantial, self-contained content that users might modify or reuse, displayed in a separate UI window for clarity.

# Good artifacts are...
- Substantial content (>15 lines)
- Content that the user is likely to modify, iterate on, or take ownership of
- Self-contained, complex content that can be understood on its own, without context from the conversation
- Content intended for eventual use outside the conversation (e.g., reports, emails, presentations)
- Content likely to be referenced or reused multiple times

ShawonAshraf

import os
import shutil

if os.path.exists(".cache/distilabel"):
    shutil.rmtree(".cache/distilabel")


from distilabel.steps.tasks import TextGeneration
from distilabel.steps import LoadHubDataset
from distilabel.pipeline.local import Pipeline

ShawonAshraf

import openai
from pydantic import BaseModel, Field
import json

class ResponseStructure(BaseModel):
    bookname: str = Field(..., title="Book Name")
    author: str = Field(..., title="Author")
    reading_list_name: str = Field(..., title="Reading List Name")
    
    

ShawonAshraf

#include "stm32f4xx.h"
#include "stm32f4xx_hal.h"

ADC_HandleTypeDef hadc1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);

int main(void) {

ShawonAshraf

# Import the required libraries
from collections import defaultdict

# Define the Chu-Liu/Edmonds algorithm function
def chu_liu_edmonds(graph):
    # Step 1: Contract the graph to a single node
    contracted_node = max(graph.keys()) + 1
    contracted_graph = defaultdict(list)
    for node in graph:
        for (weight, child) in graph[node]:

ShawonAshraf

import pynvml

pynvml.nvmlInit()

device_count = pynvml.nvmlDeviceGetCount()

for i in range(device_count):
    try:
        handle = pynvml.nvmlDeviceGetHandleByIndex(i)
        util = pynvml.nvmlDeviceGetUtilizationRates(handle)

ShawonAshraf

import torch.nn as nn
from einops.layers.torch import Rearrange
from transformers import AutoModel


class DummyModel(nn.Module):
    def __init__(self, textmodel_weight_name, task_name, batch_size, freeze_text_model=False):
        super(DummyModel, self).__init__()

        self.task_name = task_name

ShawonAshraf

# /lib/systemd/system/gpupowerlimiter.service

[Unit]
Description="Limit Nvidia GPU power at each reboot using nvidia-smi"

[Service]
User=root
Group=root
ExecStartPre=/usr/bin/nvidia-smi -i 0 -pm ENABLED
ExecStart=/usr/bin/nvidia-smi -pl 280