libraries

2024-04-23

Evm Emulation, Abi To Api

2023-05-04

Agi That Controls Computer

make specialized (in RPA) tokenizer and embedding for this new model. add new words to the tokenizer.

you can just boot ubuntu/kali/parrot iso without installing.

but that would make us embarrasing. we need to check for the option.

use ChatGPT-derived projects for localized propaganda on CyberGod and The Frozen Forest.

obs remote control

using obs-websocket you can use python to do real scripting. but first spin up obs first (with websocket related commandline arguments)

launch obs in minimized way obs --minimize-to-tray or just using xvfb.

you can also write and load scripts for obs, run on custom intervals and conditions.

audio recording

your OS may go slient if you want to record audio from “speakers”

using pyaudio, on macos, you need blackhole for sending all audio to oblivion, thus able to be recorded.

on Linux, you need audio loopback device.

run: sudo modprobe snd-aloop

you use hw:1:0 or “Analog Device Output” for slient output/speaker, and use hw:1:1 or “Analog Device Input” for recording.

benchmarks

it is always a mystery for us to develop the right ML model. however, we can setup guidelines of good performance over specific task.

automate the benchmark, setup metrics. there could be more room for trials and imagination.

encoding

use hfft/rfft to transform multipart inputs (special bits, different part of mouse coords (x, y, dx, dy))

if you want to use complex number as RNN input, you may need to swap ViT for ComplexConv2D, but maybe you just need a few.

libraries that handle complex neural networks:

complexPyTorch

pytorch-complex

multimodal

do our model have to output multimodal data?

if you combine some “special” bits along with token embeding by ihfft, you may have to retrain the entire damn network. also in order to make way for special bits, you may have to introduce extra linear layer.

some may prefer “LoRA”? by only introducing few tunable params and changing the overall output?

we may not annotate anything in our dataset. in contrast, we will set goals and make multiple interfaces for our model to explore.

you can add special task specific embedding before passing to main model, then minus that task specific embedding after passing to classification model.

make sure you don’t share important files as read/write on VM.

you may host some “execution server” on UTM VMs. you may expose your very large hard disk using WebDAV server. i think x11vnc and other vnc server may suffice for linux, but we always want to listen to the real operational data, including human operation/intervention, not just those in VNC protocols.

WebDAV servers:

wsgidav (python)

1 2	wsgidav --host=192.168.64.1 --port=8081 --root="/Volumes/Toshiba XG3/works/agi_computer_control" --auth=anonymous

webdav-cli （nodejs)

1 2	webdav-cli --host=192.168.64.1 --port=8081 --username=root --password=root --path="/Volumes/Toshiba XG3/works/agi_computer_control"

video recording

for Ubuntu ARM VM, mss failed on wayland but pyautogui works in both cases. write one python script to pipe raw images to ffmpeg for better compression ratio by shell. the final video is not “time-accurate”. it is frame by frame, matched with timestamps.

forcing ubuntu to use xorg by: sudo vim /etc/gdm3/custom.conf

resize UTM VM disks

you need to first resize the virtio disk in utm setting, then resize partition by using gparted, then update the device mapper

2022-12-22

Spring, Orm, Kotlin, Yaml Config, Jsp

There are several popular ORM (Object-Relational Mapping) libraries that you can use with Kotlin. Some of the most popular options include:

Hibernate: Hibernate is a popular and widely used ORM library that is written in Java, but can be used with Kotlin. It provides a range of features including object-relational mapping, automatic database schema generation, and support for multiple database systems.

Room: Room is an ORM library that is specifically designed for use with Android and Kotlin. It provides an easy-to-use API for accessing and manipulating SQLite databases, and is widely used in Android development.

Exposed: Exposed is a lightweight and flexible ORM library for Kotlin that is built on top of JDBC (Java Database Connectivity). It provides a range of features including support for transactions, stored procedures, and database views.

JOOQ: JOOQ (Java Object Oriented Querying) is a popular ORM library that provides a type-safe way to write SQL queries in Java and Kotlin. It generates Java code based on your database schema, allowing you to write queries using a fluent API.

Ktor-Exposed: Ktor-Exposed is an ORM library that is built on top of Exposed and is designed for use with the Ktor web framework. It provides a convenient way to access and manipulate database data within the context of a Ktor application.

use exposed in kotlin

To use Exposed in Kotlin, you will need to add the Exposed library to your project dependencies. If you are using Gradle, you can add the following dependency to your build.gradle file:

1 2	implementation 'org.jetbrains.exposed:exposed:0.24.1'

Next, you will need to create a database connection and configure the Exposed library to use it. Here is an example of how you might do this using a MySQL database:

import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.transaction
import org.jetbrains.exposed.sql.SchemaUtils.create
import org.jetbrains.exposed.sql.SchemaUtils.drop
fun main() {
// Connect to the database
Database.connect("jdbc:mysql://localhost/mydatabase", "com.mysql.cj.jdbc.Driver", "username", "password")
// Define your database schema
transaction {
create(Users)
create(Orders)
// Insert some data
Users.insert {
it[name] = "Alice"
it[age] = 25
}
// Query the data
val alice = Users.select { Users.name eq "Alice" }.single()
println("Alice's age is ${alice[Users.age]}")
// Update the data
Users.update({ Users.name eq "Alice" }) {
it[age] = 26
}
// Delete the data
Users.deleteWhere { Users.name eq "Alice" }
}
}
// Define your table and columns
object Users : Table() {
val id = integer("id").autoIncrement().primaryKey()
val name = varchar("name", length = 50)
val age = integer("age")
}
object Orders : Table() {
val id = integer("id").autoIncrement().primaryKey()
val userId = integer("user_id").references(Users.id)
val product = varchar("product", length = 50)
val quantity = integer("quantity")
}

This example demonstrates how to create a database table, insert data, query data, update data, and delete data using Exposed and Kotlin.

can spring use yaml or json for configuration

Yes, Spring can use YAML (YAML Ain’t Markup Language) or JSON (JavaScript Object Notation) for configuration.

Spring provides support for using YAML and JSON as an alternative to traditional property files for defining application configuration. To use YAML or JSON for configuration, you will need to include the spring-boot-configuration-processor dependency in your project and use the @ConfigurationProperties annotation to bind your configuration to a Java bean.

Here is an example of how you might use YAML for configuration in a Spring Boot application:

# application.yml
server:
port: 8080
app:
name: My App
version: 1.0.0
greeting: Hello, world!

@ConfigurationProperties("app")
class AppProperties {
lateinit var name: String
lateinit var version: String
lateinit var greeting: String
}

You can then inject the AppProperties bean into your application and use the configuration values like this:

@RestController
class HelloController(private val appProperties: AppProperties) {
@GetMapping("/")
fun hello() = appProperties.greeting
}

You can use a similar approach to use JSON for configuration in your Spring Boot application.

demonstrate aspect oriented programming in kotlin

Aspect-Oriented Programming (AOP) is a programming paradigm that aims to modularize cross-cutting concerns, such as logging, security, and transaction management, into distinct aspects that can be applied to multiple parts of an application.

In Kotlin, you can use the Spring Framework’s AOP support to implement aspect-oriented programming. Here is an example of how you might use AOP to log the execution of a method in Kotlin:

import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Before
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Component
@Aspect
@Component
class LoggingAspect {
val logger: Logger = LoggerFactory.getLogger(LoggingAspect::class.java)
@Before("execution(* com.example.service.*.*(..))")
fun logMethodExecution() {
logger.info("Method execution")
}
}

In this example, the @Aspect annotation indicates that this class represents an aspect, and the @Before annotation specifies a pointcut (a point in the code where the aspect should be applied) and an advice (the action that should be taken when the pointcut is reached). In this case, the pointcut matches any method execution in the com.example.service package, and the advice logs a message.

To use this aspect in your application, you will need to enable AOP support in your Spring configuration. You can do this by adding the @EnableAspectJAutoProxy annotation to your configuration class, like this:

import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.EnableAspectJAutoProxy
@Configuration
@EnableAspectJAutoProxy
class AopConfiguration

With these changes in place, the aspect will be applied to all matching method executions in your application and the log message will be printed whenever a method is executed.

use spring mvc in kotlin

To use Spring MVC (Model-View-Controller) in Kotlin, you will need to create a Spring Boot application and add the spring-boot-starter-web dependency to your project.

Here is an example of how you might set up a simple Spring MVC application in Kotlin:

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.stereotype.Controller
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.ResponseBody
@SpringBootApplication
class Application
fun main(args: Array<String>) {
runApplication<Application>(*args)
}
@Controller
class HelloController {
@GetMapping("/")
@ResponseBody
fun hello() = "Hello, world!"
}

In this example, the HelloController class is annotated with @Controller to indicate that it is a Spring MVC controller. The hello() method is annotated with @GetMapping to specify that it should handle HTTP GET requests to the root URL, and with @ResponseBody to indicate that the method’s return value should be written directly to the HTTP response body.

With these changes in place, you can start your Spring Boot application and visit http://localhost:8080 in your web browser to see the “Hello, world!” message.

You can use similar annotations to handle other HTTP methods, such as POST, PUT, and DELETE, and to bind request parameters to method arguments. You can also use the @RequestMapping annotation to specify more complex URL patterns, and the @ModelAttribute annotation to bind request parameters to model attributes that can be used in view templates.

use jsp with spring in kotlin

To use JSP (Java Server Pages) with Spring in Kotlin, you will need to create a Spring Boot application and add the spring-boot-starter-web and spring-boot-starter-tomcat dependencies to your project.

By default, Spring Boot will look for JSP files in the src/main/webapp/WEB-INF/jsp directory. You will need to create this directory structure and add your JSP files to it.

Here is an example of a simple JSP file that displays a message:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>Hello</title>
</head>
<body>
<h1>Hello, world!</h1>
</body>
</html>

To render this JSP file in your Spring MVC application, you will need to create a controller that maps a request to the JSP file. Here is an example of how you might do this in Kotlin:

import org.springframework.stereotype.Controller
import org.springframework.web.bind.annotation.GetMapping
@Controller
class HelloController {
@GetMapping("/")
fun hello() = "hello"
}

In this example, the hello() method is annotated with @GetMapping to specify that it should handle HTTP GET requests to the root URL. The method’s return value, “hello”, is the name of the JSP file that should be rendered in response to the request.

With these changes in place, you can start your Spring Boot application and visit http://localhost:8080 in your web browser to see the message displayed by the JSP file.

You can use similar approaches to map requests to other JSP files and to pass data from your controllers to your JSP files using model attributes.

2024-04-23 Evm Emulation, Abi To Api

2023-05-04 Agi That Controls Computer