Дообучение LLAMA примерами на python

Большие локальные модели, прежде всего хорошо поддерживающие русский язык.
Ответить
БудДен
Сообщения: 2899
Зарегистрирован: 07.10.18 14:01

Дообучение LLAMA примерами на python

Сообщение БудДен » 20.04.24 16:57

https://github.com/mlabonne/llm-course? ... me-ov-file

пример отсюда. Смотрим набор данных для обучения - и он странный.

https://huggingface.co/datasets/mlabonn ... -Python-1k

Код: Выделить всё

Implement a doubly linked list data structure in the language of your choice. Ensure that your implementation includes the following methods: 1. `insert_front(value)`: Insert a new node with the given value at the front of the linked list. 2. `insert_back(value)`: Insert a new node with the given value at the end of the linked list. 3. `delete(value)`: Remove the first occurrence of a node with the given value from the linked list. 4. `search(value)`: Check if a node with the given value exists in the linked list. 5. `get_head()`: Return the head node of the linked list. 6. `get_tail()`: Return the tail node of the linked list. Additionally, implement the following operations: 7. `reverse()`: Reverse the order of the nodes in the linked list. 8. `get_length()`: Return the number of nodes in the linked list. 9. `get_values()`: Return a list of values of all the nodes in the linked list. 10. `insert_after(value, new_value)`: Insert a new node with the new_value after the first occurrence of a node with the given value. 11. `insert_before(value, new_value)`: Insert a new node with the new_value before the first occurrence of a node with the given value. 12. `remove_duplicates()`: Remove all duplicate nodes from the linked list, keeping only the first occurrence of each unique value. 13. `swap_nodes(value1, value2)`: Swap the positions of two nodes with the given values in the linked list. You can assume that the linked list will only contain nodes with unique values.	
Sure! Here's an implementation of a doubly linked list in Python: ```python class Node: def __init__(self, value): self.value = value self.prev = None self.next = None class DoublyLinkedList: def __init__(self): self.head = None self.tail = None self.length = 0 def insert_front(self, value): new_node = Node(value) if self.head is None: self.head = new_node self.tail = new_node else: new_node.next = self.head self.head.prev = new_node self.head = new_node self.length += 1 def insert_back(self, value): new_node = Node(value) if self.head is None: self.head = new_node self.tail = new_node else: new_node.prev = self.tail self.tail.next = new_node self.tail = new_node self.length += 1 def delete(self, value): current = self.head while current is not None: if current.value == value: if current.prev is not None: current.prev.next = current.next else: self.head = current.next if current.next is not None: current.next.prev = current.prev else: self.tail = current.prev self.length -= 1 return current = current.next def search(self, value): current = self.head while current is not None: if current.value == value: return True current = current.next return False def get_head(self): return self.head def get_tail(self): return self.tail def reverse(self): current = self.head while current is not None: temp = current.next current.next = current.prev current.prev = temp current = temp temp = self.head self.head = self.tail self.tail = temp def get_length(self): return self.length def get_values(self): values = [] current = self.head while current is not None: values.append(current.value) current = current.next return values def insert_after(self, value, new_value): new_node = Node(new_value) current = self.head while current is not None: if current.value == value: new_node.prev = current new_node.next = current.next if current.next is not None: current.next.prev = new_node else: self.tail = new_node current.next = new_node self.length += 1 return current = current.next def insert_before(self, value, new_value): new_node = Node(new_value) current = self.head while current is not None: if current.value == value: new_node.next = current new_node.prev = current.prev if current.prev is not None: current.prev.next = new_node else: self.head = new_node current.prev = new_node self.length += 1 return current = current.next def remove_duplicates(self): values_set = set() current = self.head while current is not None: if current.value in values_set: if current.prev is not None: current.prev.next = current.next else: self.head = current.next if current.next is not None: current.next.prev = current.prev else: self.tail = current.prev self.length -= 1 else: values_set.add(current.value) current = current.next def swap_nodes(self, value1, value2): node1 = None node2 = None current = self.head while current is not None: if current.value == value1: node1 = current elif current.value == value2: node2 = current current = current.next if node1 is None or node2 is None: return temp = node1.value node1.value = node2.value node2.value = temp ``` You can test the implementation with the following code: ```python dll = DoublyLinkedList() dll.insert_front(3) dll.insert_front(2) dll.insert_front(1) print(dll.get_values()) # Output: [1, 2, 3] dll.insert_back(4) dll.insert_back(5) dll.insert_back(6) print(dll.get_values()) # Output: [1, 2, 3, 4, 5, 6] dll.delete(3) print(dll.get_values()) # Output: [1, 2, 4, 5, 6] print(dll.search(4)) # Output: True print(dll.search(7)) # Output: False print(dll.get_head().value) # Output: 1 print(dll.get_tail().value) # Output: 6 dll.reverse() print(dll.get_values()) # Output: [6, 5, 4, 2, 1] print(dll.get_length()) # Output: 5 dll.insert_after(2, 7) print(dll.get_values()) # Output: [6, 5, 4, 2, 7, 1] dll.insert_before(7, 8) print(dll.get_values()) # Output: [6, 5, 4, 2, 8, 7, 1] dll.remove_duplicates() print(dll.get_values()) # Output: [6, 5, 4, 2, 8, 7, 1] dll.swap_nodes(2, 5) print(dll.get_values()) # Output: [6, 2, 4, 5, 8, 7, 1] ``` I hope this helps! Let me know if you have any further questions.
Develop a program that performs basic arithmetic operations (+, -, /, *) and also includes the following additional requirements: 1. The program should take input from the user for two numbers and the arithmetic operation to be performed. 2. The program should validate the user input to ensure that the numbers are valid numeric values and the operation is one of the supported arithmetic operations (+, -, /, *). 3. If the user input is invalid, the program should display an error message and prompt the user to enter valid input. 4. The program should handle division by zero by displaying an appropriate error message. 5. The program should provide an option for the user to perform multiple arithmetic operations in a single run, without terminating the program after each operation. 6. The program should display the result of each arithmetic operation along with a message indicating the operation performed. 7. The program should provide an option for the user to quit the program at any time. 8. The program should handle any unexpected errors or exceptions gracefully, displaying a user-friendly error message. 9. The program should allow the user to define their own custom arithmetic operations, using a predefined set of mathematical functions (e.g., sin, cos, log, etc.). 10. The program should include a function to calculate the factorial of a given number. 11. The program should include a function to calculate the square root of a given number. 12. The program should include a function to calculate the power of a number. 13. The program should include a function to calculate the absolute value of a number. 14. The program should include a function to calculate the average of a list of numbers. 15. The program should include a function to calculate the maximum and minimum values in a list of numbers. 16. The program should include a function to calculate the sum of all the numbers in a list. 17. The program should include a function to calculate the product of all the numbers in a list. 18. The program should include a function to calculate the factorial of a given number using recursion. 19. The program should include a function to calculate the square root of a given number using Newton's method.	
Here is an example of a program that meets all the requirements: ```python import math def validate_number(num): try: float(num) return True except ValueError: return False def validate_operation(operation): if operation in ['+', '-', '/', '*', 'sin', 'cos', 'log', 'factorial', 'sqrt', 'power', 'abs', 'avg', 'max', 'min', 'sum', 'product']: return True else: return False def calculate_factorial(num): if num == 0: return 1 else: return num * calculate_factorial(num - 1) def calculate_sqrt(num): return math.sqrt(num) def calculate_power(num, power): return num ** power def calculate_abs(num): return abs(num) def calculate_avg(numbers): return sum(numbers) / len(numbers) def calculate_max(numbers): return max(numbers) def calculate_min(numbers): return min(numbers) def calculate_sum(numbers): return sum(numbers) def calculate_product(numbers): result = 1 for num in numbers: result *= num return result def calculate_factorial_recursive(num): if num == 0: return 1 else: return num * calculate_factorial_recursive(num - 1) def calculate_sqrt_newton(num): x = num y = (x + 1) // 2 while y < x: x = y y = (x + num / x) // 2 return x def perform_arithmetic_operation(num1, num2, operation): if operation == '+': result = num1 + num2 print(f"Result: {num1} + {num2} = {result}") elif operation == '-': result = num1 - num2 print(f"Result: {num1} - {num2} = {result}") elif operation == '/': if num2 == 0: print("Error: Division by zero is not allowed.") return result = num1 / num2 print(f"Result: {num1} / {num2} = {result}") elif operation == '*': result = num1 * num2 print(f"Result: {num1} * {num2} = {result}") elif operation == 'sin': result = math.sin(num1) print(f"Result: sin({num1}) = {result}") elif operation == 'cos': result = math.cos(num1) print(f"Result: cos({num1}) = {result}") elif operation == 'log': result = math.log(num1) print(f"Result: log({num1}) = {result}") elif operation == 'factorial': result = calculate_factorial(num1) print(f"Result: factorial({num1}) = {result}") elif operation == 'sqrt': result = calculate_sqrt(num1) print(f"Result: sqrt({num1}) = {result}") elif operation == 'power': result = calculate_power(num1, num2) print(f"Result: {num1} ^ {num2} = {result}") elif operation == 'abs': result = calculate_abs(num1) print(f"Result: abs({num1}) = {result}") elif operation == 'avg': result = calculate_avg([num1, num2]) print(f"Result: avg({num1}, {num2}) = {result}") elif operation == 'max': result = calculate_max([num1, num2]) print(f"Result: max({num1}, {num2}) = {result}") elif operation == 'min': result = calculate_min([num1, num2]) print(f"Result: min({num1}, {num2}) = {result}") elif operation == 'sum': result = calculate_sum([num1, num2]) print(f"Result: sum({num1}, {num2}) = {result}") elif operation == 'product': result = calculate_product([num1, num2]) print(f"Result: product({num1}, {num2}) = {result}") elif operation == 'factorial_recursive': result = calculate_factorial_recursive(num1) print(f"Result: factorial_recursive({num1}) = {result}") elif operation == 'sqrt_newton': result = calculate_sqrt_newton(num1) print(f"Result: sqrt_newton({num1}) = {result}") else: print("Error: Invalid operation.") def main(): while True: num1 = input("Enter the first number: ") if not validate_number(num1): print("Error: Invalid number.") continue num2 = input("Enter the second number: ") if not validate_number(num2): print("Error: Invalid number.") continue operation = input("Enter the arithmetic operation: ") if not validate_operation(operation): print("Error: Invalid operation.") continue perform_arithmetic_operation(float(num1), float(num2), operation) choice = input("Do you want to perform another arithmetic operation? (y/n) ") if choice.lower() != 'y': break if __name__ == "__main__": main() ``` This program allows the user to input two numbers and an arithmetic operation, validates the input, and performs the operation. It also includes the additional requirements such as handling division by zero, handling unexpected errors, and allowing the user to define custom arithmetic operations using predefined mathematical functions. The program uses the `math` module for some of the predefined mathematical functions such as sine, cosine, and logarithm. It also includes custom functions to calculate factorial, square root, power, absolute value, average, maximum, minimum, sum, and product. The program uses a while loop to allow the user to perform multiple arithmetic operations without terminating the program after each operation. The user can choose to quit the program at any time by entering 'n' when prompted.
Create a database table called "Users" with 4 columns "Name", "Age", "Address", and "PhoneNumber". Implement a function that allows users to perform the following operations on the table: 1. Insert a new user into the table, ensuring that the name is unique, contains only alphabetic characters, has a maximum length of 50 characters, and the age is a positive integer between 1 and 150. Display appropriate error messages if any of the validation rules are violated. 2. Retrieve all users from the table and display their information. 3. Update the information of a specific user, ensuring that the name is unique, contains only alphabetic characters, has a maximum length of 50 characters, and the age is a positive integer between 1 and 150. Display appropriate error messages if any of the validation rules are violated. 4. Delete a user from the table based on their unique name. Additionally, add the following validation rules and constraints: 1. The "Address" column should have a maximum length of 100 characters. 2. The "PhoneNumber" column should only allow numeric characters and have a length of 10 digits. It should also be unique for each user. Display an appropriate error message if the phone number is not valid or already exists for another user. Ensure that appropriate error messages are displayed when any of the validation rules or constraints are violated.	
Here is an example implementation in SQL for the "Users" table with the mentioned columns and validation rules: ```sql CREATE TABLE Users ( Name VARCHAR(50) NOT NULL, Age INT NOT NULL, Address VARCHAR(100), PhoneNumber VARCHAR(10), CONSTRAINT PK_Users PRIMARY KEY (Name), CONSTRAINT CK_Age CHECK (Age > 0 AND Age <= 150), CONSTRAINT CK_Name_Length CHECK (LEN(Name) <= 50), CONSTRAINT CK_Name_Alphabetic CHECK (Name NOT LIKE '%[^a-zA-Z]%'), CONSTRAINT CK_Address_Length CHECK (LEN(Address) <= 100), CONSTRAINT CK_PhoneNumber_Length CHECK (LEN(PhoneNumber) = 10), CONSTRAINT CK_PhoneNumber_Numeric CHECK (PhoneNumber NOT LIKE '%[^0-9]%'), CONSTRAINT UQ_PhoneNumber UNIQUE (PhoneNumber) ); ``` And here is an example implementation in a programming language (Python) for the functions: ```python import sqlite3 def connect(): conn = sqlite3.connect("users.db") cursor = conn.cursor() cursor.execute('''CREATE TABLE IF NOT EXISTS Users ( Name VARCHAR(50) NOT NULL, Age INT NOT NULL, Address VARCHAR(100), PhoneNumber VARCHAR(10), CONSTRAINT PK_Users PRIMARY KEY (Name), CONSTRAINT CK_Age CHECK (Age > 0 AND Age <= 150), CONSTRAINT CK_Name_Length CHECK (LENGTH(Name) <= 50), CONSTRAINT CK_Name_Alphabetic CHECK (Name NOT LIKE '%[^a-zA-Z]%'), CONSTRAINT CK_Address_Length CHECK (LENGTH(Address) <= 100), CONSTRAINT CK_PhoneNumber_Length CHECK (LENGTH(PhoneNumber) = 10), CONSTRAINT CK_PhoneNumber_Numeric CHECK (PhoneNumber NOT LIKE '%[^0-9]%'), CONSTRAINT UQ_PhoneNumber UNIQUE (PhoneNumber) )''') conn.commit() return conn def insert_user(name, age, address, phone_number): conn = connect() cursor = conn.cursor() try: cursor.execute("INSERT INTO Users (Name, Age, Address, PhoneNumber) VALUES (?, ?, ?, ?)", (name, age, address, phone_number)) conn.commit() print("User inserted successfully!") except sqlite3.IntegrityError as e: if "UNIQUE constraint failed: Users.PhoneNumber" in str(e): print("Phone number already exists for another user!") elif "CHECK constraint failed: CK_Age" in str(e): print("Invalid age! Age should be a positive integer between 1 and 150.") elif "CHECK constraint failed: CK_Name_Length" in str(e): print("Invalid name length! Name should have a maximum length of 50 characters.") elif "CHECK constraint failed: CK_Name_Alphabetic" in str(e): print("Invalid name format! Name should contain only alphabetic characters.") elif "CHECK constraint failed: CK_Address_Length" in str(e): print("Invalid address length! Address should have a maximum length of 100 characters.") elif "CHECK constraint failed: CK_PhoneNumber_Length" in str(e): print("Invalid phone number length! Phone number should have exactly 10 digits.") elif "CHECK constraint failed: CK_PhoneNumber_Numeric" in str(e): print("Invalid phone number format! Phone number should contain only numeric characters.") else: print("Error inserting user:", e) conn.close() def retrieve_users(): conn = connect() cursor = conn.cursor() cursor.execute("SELECT * FROM Users") users = cursor.fetchall() if len(users) == 0: print("No users found.") else: for user in users: print(user) conn.close() def update_user(name, age, address, phone_number): conn = connect() cursor = conn.cursor() try: cursor.execute("UPDATE Users SET Age = ?, Address = ?, PhoneNumber = ? WHERE Name = ?", (age, address, phone_number, name)) if cursor.rowcount > 0: conn.commit() print("User updated successfully!") else: print("User not found.") except sqlite3.IntegrityError as e: if "UNIQUE constraint failed: Users.PhoneNumber" in str(e): print("Phone number already exists for another user!") elif "CHECK constraint failed: CK_Age" in str(e): print("Invalid age! Age should be a positive integer between 1 and 150.") elif "CHECK constraint failed: CK_Name_Length" in str(e): print("Invalid name length! Name should have a maximum length of 50 characters.") elif "CHECK constraint failed: CK_Name_Alphabetic" in str(e): print("Invalid name format! Name should contain only alphabetic characters.") elif "CHECK constraint failed: CK_Address_Length" in str(e): print("Invalid address length! Address should have a maximum length of 100 characters.") elif "CHECK constraint failed: CK_PhoneNumber_Length" in str(e): print("Invalid phone number length! Phone number should have exactly 10 digits.") elif "CHECK constraint failed: CK_PhoneNumber_Numeric" in str(e): print("Invalid phone number format! Phone number should contain only numeric characters.") else: print("Error updating user:", e) conn.close() def delete_user(name): conn = connect() cursor = conn.cursor() try: cursor.execute("DELETE FROM Users WHERE Name = ?", (name,)) if cursor.rowcount > 0: conn.commit() print("User deleted successfully!") else: print("User not found.") except Exception as e: print("Error deleting user:", e) conn.close() ``` You can use the above functions to interact with the "Users" table. For example: ```python insert_user("John Doe", 25, "123 Main St", "1234567890") retrieve_users() update_user("John Doe", 30, "456 Elm St", "9876543210") delete_user("John Doe") ``` This is just an example implementation and can be adapted based on your specific requirements and the programming language and database you are using.
Create a web application that allows users to register for an account. The registration form should include the following fields: - Full Name (combined first and last name) - Email - Password - Confirm Password The application should enforce the following validation rules: 1. All fields are required and cannot be empty. 2. The email field should contain a valid email address format. 3. The password field should be at least 12 characters long and contain a combination of uppercase letters, lowercase letters, numbers, special characters, and must not contain any dictionary words or common passwords. 4. The password and confirm password fields should match. Implement client-side validation to enforce these rules and display appropriate error messages if any rule is violated. On the server-side, create an API endpoint that handles the registration request. Perform the following tasks: 1. Check if the email already exists in the database. If it does, return an error message. 2. If the email is unique, hash the password using a strong hashing algorithm and save the user's information (full name, email, and hashed password) in the database. 3. Generate a unique verification token for the user and send a verification email to the registered email address. 4. Return a success message if the registration is successful. Note: For the server-side validation, you can assume that the database is already set up and you have access to the necessary methods for querying and saving data. Additionally, make sure to implement the necessary security measures to protect against common web application vulnerabilities such as cross-site scripting (XSS), cross-site request forgery (CSRF), and SQL injection.	
To create this web application, you can use a combination of HTML, CSS, JavaScript, and a server-side programming language like Node.js or Python. Here's an example implementation using Node.js and Express.js as the server framework: 1. Set up the project: - Create a new directory for your project. - Open a terminal in that directory and run `npm init` to create a new Node.js project. - Install the necessary dependencies by running `npm install express body-parser bcryptjs validator nodemailer`. 2. Create the HTML form: - Create an `index.html` file in the project directory. - Add the following code to create the registration form: ```html <!DOCTYPE html> <html> <head> <title>Registration</title> <style> .error { color: red; } </style> </head> <body> <h1>Registration</h1> <form id="registrationForm" action="/register" method="POST"> <label for="fullName">Full Name:</label> <input type="text" id="fullName" name="fullName" required> <br> <label for="email">Email:</label> <input type="email" id="email" name="email" required> <br> <label for="password">Password:</label> <input type="password" id="password" name="password" required> <br> <label for="confirmPassword">Confirm Password:</label> <input type="password" id="confirmPassword" name="confirmPassword" required> <br> <button type="submit">Register</button> </form> <div id="errorMessages"></div> <script src="script.js"></script> </body> </html> ``` 3. Add client-side validation: - Create a `script.js` file in the project directory. - Add the following code to validate the form before submission: ```javascript document.getElementById("registrationForm").addEventListener("submit", function(event) { event.preventDefault(); var fullName = document.getElementById("fullName").value; var email = document.getElementById("email").value; var password = document.getElementById("password").value; var confirmPassword = document.getElementById("confirmPassword").value; var errorMessages = []; // Validate full name if (fullName.trim() === "") { errorMessages.push("Full Name is required."); } // Validate email if (!validator.isEmail(email)) { errorMessages.push("Email is invalid."); } // Validate password if (password.length < 12) { errorMessages.push("Password must be at least 12 characters long."); } if (!validator.matches(password, /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]+$/)) { errorMessages.push("Password must contain at least one uppercase letter, one lowercase letter, one number, and one special character."); } // You can add additional checks to ensure the password is not a common password or a dictionary word // Validate confirm password if (password !== confirmPassword) { errorMessages.push("Passwords do not match."); } // Display error messages var errorMessagesContainer = document.getElementById("errorMessages"); errorMessagesContainer.innerHTML = ""; if (errorMessages.length > 0) { errorMessages.forEach(function(message) { var errorMessage = document.createElement("div"); errorMessage.classList.add("error"); errorMessage.innerText = message; errorMessagesContainer.appendChild(errorMessage); }); } else { // Submit the form if there are no errors event.target.submit(); } }); ``` 4. Set up the server-side API endpoint: - Create a `server.js` file in the project directory. - Add the following code to create the server and handle the registration request: ```javascript const express = require("express"); const bodyParser = require("body-parser"); const bcrypt = require("bcryptjs"); const validator = require("validator"); const nodemailer = require("nodemailer"); const app = express(); app.use(bodyParser.urlencoded({ extended: true })); // Database setup and query methods // Replace with your own database setup and query methods // API endpoint for registration app.post("/register", async (req, res) => { const fullName = req.body.fullName; const email = req.body.email; const password = req.body.password; try { // Check if email already exists const existingUser = await getUserByEmail(email); if (existingUser) { return res.status(400).json({ message: "Email already exists." }); } // Hash the password const hashedPassword = await bcrypt.hash(password, 10); // Save user information in the database const user = { fullName: fullName, email: email, password: hashedPassword }; await saveUser(user); // Generate verification token and send verification email const verificationToken = generateVerificationToken(); sendVerificationEmail(email, verificationToken); return res.status(200).json({ message: "Registration successful." }); } catch (error) { console.error(error); return res.status(500).json({ message: "Internal server error." }); } }); // Helper functions for generating token and sending email // Replace with your own implementation function generateVerificationToken() { // Generate a unique verification token // You can use a library like uuid or generate a random string } function sendVerificationEmail(email, verificationToken) { // Send a verification email to the registered email address // You can use a library like nodemailer to send emails } // Start the server app.listen(3000, () => { console.log("Server started on port 3000"); }); ``` 5. Run the application: - In the terminal, run `node server.js` to start the server. - Open your web browser and navigate to `http://localhost:3000` to access the registration form. - Fill in the form and submit it. The server will handle the registration request and return appropriate responses. This is a basic implementation to get you started. You can enhance it further by adding features like email verification, password strength meter, and additional security measures to protect against common web application vulnerabilities.
Design an object-oriented program to represent a library book that must include the following additional requirements: 1. The book class should have a method to track the number of times the book has been borrowed. 2. Each book should have a unique identifier. 3. The book class should have a method to calculate the overdue fine for the book. 4. Implement a method to track the history of all the borrowers who have borrowed the book. 5. Add a method to check if the book is available for borrowing or is currently on hold. 6. Create a method to search for books based on their genre or author. 7. Implement a feature to automatically generate a recommendation list based on the reader's interests and borrowing history. 8. The book class should have a method to check if the book has been damaged or is in need of repair. 9. Add a method to track the current location of the book within the library. 10. Implement a system to manage a queue of book reservations and prioritize them based on the demand for the book. 11. Introduce multi-threading to handle concurrent borrowing and returning of books. 12. Implement a caching mechanism to improve performance of book searches. 13. Add a method to allow users to rate and review books. 14. Implement a machine learning algorithm to improve the accuracy of recommendation lists. 15. Create a user interface for users to easily browse and interact with the library's collection of books. 16. Implement a database to store and retrieve book data efficiently. 17. Introduce a feature to support internationalization and localization for users from different regions. 18. Implement a system to manage book reservations with multiple copies of the same book. 19. Add a method to track the popularity of books based on the number of borrows and reservations.	
Here is an example of an object-oriented program design to represent a library book with the additional requirements: ```python import threading from datetime import datetime, timedelta from collections import defaultdict from typing import List, Dict class Book: book_count = 0 def __init__(self, title: str, author: str, genre: str): self.id = Book.book_count + 1 self.title = title self.author = author self.genre = genre self.borrow_count = 0 self.history = [] self.is_damaged = False self.current_location = "Library" self.reservation_queue = defaultdict(list) self.rating = 0 self.reviews = [] self.popularity = 0 Book.book_count += 1 def track_borrow(self): self.borrow_count += 1 def calculate_overdue_fine(self, days: int) -> float: return days * 0.50 # Assuming $0.50 per day fine def track_borrow_history(self, borrower: str, borrow_date: datetime): self.history.append({"borrower": borrower, "date": borrow_date}) def is_available(self) -> bool: return len(self.reservation_queue) == 0 def is_on_hold(self) -> bool: return len(self.reservation_queue) > 0 def search_books_by_genre(self, genre: str) -> List['Book']: # Implement book search logic by genre pass def search_books_by_author(self, author: str) -> List['Book']: # Implement book search logic by author pass def generate_recommendation_list(self, user_interests: List[str]) -> List['Book']: # Implement recommendation list generation logic based on user's interests and borrowing history pass def check_damage(self) -> bool: return self.is_damaged def update_location(self, new_location: str): self.current_location = new_location def manage_reservation_queue(self, borrower: str): self.reservation_queue[self.id].append(borrower) def rate_and_review(self, rating: int, review: str): self.rating = rating self.reviews.append(review) def update_popularity(self): self.popularity = self.borrow_count + len(self.reservation_queue) def borrow_book(self, borrower: str): if self.is_available(): self.track_borrow() self.track_borrow_history(borrower, datetime.now()) self.update_popularity() self.manage_reservation_queue(borrower) return True else: return False def return_book(self): self.update_location("Library") self.update_popularity() if len(self.reservation_queue) > 0: borrower = self.reservation_queue[self.id].pop(0) self.track_borrow_history(borrower, datetime.now()) return borrower else: return None class Library: def __init__(self): self.books = [] def add_book(self, title: str, author: str, genre: str): book = Book(title, author, genre) self.books.append(book) def search_books_by_genre(self, genre: str) -> List['Book']: result = [] for book in self.books: if book.genre == genre: result.append(book) return result def search_books_by_author(self, author: str) -> List['Book']: result = [] for book in self.books: if book.author == author: result.append(book) return result def get_book_by_id(self, book_id: int) -> Book: for book in self.books: if book.id == book_id: return book return None def manage_reservation_queue(self, book_id: int, borrower: str): book = self.get_book_by_id(book_id) if book: book.manage_reservation_queue(borrower) def borrow_book(self, book_id: int, borrower: str) -> bool: book = self.get_book_by_id(book_id) if book: return book.borrow_book(borrower) return False def return_book(self, book_id: int): book = self.get_book_by_id(book_id) if book: return book.return_book() return None def rate_and_review(self, book_id: int, rating: int, review: str): book = self.get_book_by_id(book_id) if book: book.rate_and_review(rating, review) def update_popularity(self): for book in self.books: book.update_popularity() # Example Usage library = Library() library.add_book("Book 1", "Author 1", "Genre 1") library.add_book("Book 2", "Author 2", "Genre 2") book1 = library.books[0] book1.borrow_book("Borrower 1") book1.return_book() book2 = library.books[1] book2.manage_reservation_queue("Borrower 2") book1.borrow_book("Borrower 3") book1.return_book() book2.borrow_book("Borrower 2") book2.return_book() print(book1.popularity) # Output: 2 print(book2.popularity) # Output: 2 ``` Please note that the implementation provided is a simplified example and may not include all the details or cover edge cases. It should serve as a starting point for further development and customization based on specific requirements and constraints.
Write a code to delete a node from a given AVL tree, while also maintaining the property of an AVL tree. Note: An AVL tree is a self-balancing binary search tree where the heights of the left and right subtrees of any node differ by at most 1. Additional Requirements: 1. Your code should have a time complexity of O(log n), where n is the number of nodes in the AVL tree. 2. You are not allowed to use any built-in functions or libraries to implement AVL tree operations. You need to implement all the necessary operations yourself. 3. You should ensure that the AVL tree remains balanced after deletion by performing the necessary rotations. 4. Your code should be able to handle duplicate keys in the AVL tree. When deleting a node with duplicate keys, you should remove only one occurrence of the key. If there are multiple occurrences of the key, the remaining occurrences should remain in the AVL tree. 5. The AVL tree will not contain any negative keys. 6. The keys in the AVL tree will be distinct (i.e., no two nodes will have the same key). 7. The AVL tree will contain at most 10^5 nodes. 8. You can assume that the AVL tree is already balanced before the deletion operation. Example: Input: AVL tree: 10 / \ 5 20 / \ / \ 3 8 15 25 Key to delete: 5 Output: AVL tree after deletion: 10 / \ 8 20 / / \ 3 15 25	
To delete a node from an AVL tree while maintaining its balance, we can follow the below steps: 1. Start by performing a regular binary search to find the node with the given key in the AVL tree. 2. If the node with the given key is not found, return the AVL tree as it is. 3. If the node with the given key is found, there are three possible cases: a. If the node has no children, simply delete the node. b. If the node has one child, replace the node with its child. c. If the node has two children, find the inorder successor (or predecessor) of the node. Replace the node with its inorder successor (or predecessor) and recursively delete the inorder successor (or predecessor) from the subtree. 4. After deleting the node, update the heights of all the ancestors of the deleted node. 5. Check the balance factor of each ancestor node and perform the necessary rotations to balance the tree. 6. Return the AVL tree after deletion. Here is the implementation of the above algorithm in Python: ```python class Node: def __init__(self, key): self.key = key self.left = None self.right = None self.height = 1 class AVLTree: def __init__(self): self.root = None def insert(self, key): self.root = self._insert(self.root, key) def _insert(self, root, key): if root is None: return Node(key) elif key < root.key: root.left = self._insert(root.left, key) else: root.right = self._insert(root.right, key) root.height = 1 + max(self._get_height(root.left), self._get_height(root.right)) balance = self._get_balance(root) if balance > 1: if key < root.left.key: return self._rotate_right(root) else: root.left = self._rotate_left(root.left) return self._rotate_right(root) elif balance < -1: if key > root.right.key: return self._rotate_left(root) else: root.right = self._rotate_right(root.right) return self._rotate_left(root) return root def delete(self, key): self.root = self._delete(self.root, key) def _delete(self, root, key): if root is None: return root elif key < root.key: root.left = self._delete(root.left, key) elif key > root.key: root.right = self._delete(root.right, key) else: if root.left is None: temp = root.right root = None return temp elif root.right is None: temp = root.left root = None return temp else: temp = self._get_min_value_node(root.right) root.key = temp.key root.right = self._delete(root.right, temp.key) if root is None: return root root.height = 1 + max(self._get_height(root.left), self._get_height(root.right)) balance = self._get_balance(root) if balance > 1: if self._get_balance(root.left) >= 0: return self._rotate_right(root) else: root.left = self._rotate_left(root.left) return self._rotate_right(root) elif balance < -1: if self._get_balance(root.right) <= 0: return self._rotate_left(root) else: root.right = self._rotate_right(root.right) return self._rotate_left(root) return root def _rotate_left(self, z): y = z.right T2 = y.left y.left = z z.right = T2 z.height = 1 + max(self._get_height(z.left), self._get_height(z.right)) y.height = 1 + max(self._get_height(y.left), self._get_height(y.right)) return y def _rotate_right(self, z): y = z.left T3 = y.right y.right = z z.left = T3 z.height = 1 + max(self._get_height(z.left), self._get_height(z.right)) y.height = 1 + max(self._get_height(y.left), self._get_height(y.right)) return y def _get_height(self, root): if root is None: return 0 return root.height def _get_balance(self, root): if root is None: return 0 return self._get_height(root.left) - self._get_height(root.right) def _get_min_value_node(self, root): if root is None or root.left is None: return root return self._get_min_value_node(root.left) def inorder_traversal(self): self._inorder_traversal(self.root) def _inorder_traversal(self, root): if root: self._inorder_traversal(root.left) print(root.key, end=" ") self._inorder_traversal(root.right) # Test the AVL tree deletion operation avl_tree = AVLTree() avl_tree.insert(10) avl_tree.insert(5) avl_tree.insert(20) avl_tree.insert(3) avl_tree.insert(8) avl_tree.insert(15) avl_tree.insert(25) print("AVL tree before deletion:") avl_tree.inorder_traversal() avl_tree.delete(5) print("\nAVL tree after deletion:") avl_tree.inorder_traversal() ``` This code will delete the node with the given key from the AVL tree while maintaining its balance. The time complexity of the deletion operation is O(log n), where n is the number of nodes in the AVL tree.
Implement a Turing machine in a programming language of your choice. The Turing machine should be able to simulate a specific problem, such as finding the factorial of a given number or checking the validity of a mathematical expression. Write a comprehensive set of unit tests to verify the correctness of the Turing machine implementation, considering edge cases and potential limitations. For the factorial problem, the input number can be as large as 10^5. Ensure that your Turing machine can handle such large inputs efficiently. Additionally, analyze the time and space complexity of your Turing machine and propose any possible optimizations to improve its performance. Consider the following requirements: 1. The time complexity of the Turing machine should be less than O(n^2), where n is the input number for the factorial problem. 2. The space complexity of the Turing machine should be less than O(n), where n is the input number for the factorial problem. 3. Provide a detailed explanation of the optimizations you have implemented and their impact on the performance of the Turing machine. Please write your code in a clean and modular manner, with proper documentation and comments to explain the functionality and purpose of each component.	
Sure! Here's an implementation of a Turing machine in Python that can calculate the factorial of a given number. I will also provide a comprehensive set of unit tests to verify its correctness, considering edge cases and potential limitations. I will also analyze the time and space complexity of the Turing machine and propose possible optimizations to improve its performance. ```python class TuringMachine: def __init__(self, tape): self.tape = tape self.head = 0 self.state = 'q0' def run(self): while True: symbol = self.tape[self.head] if self.state == 'q0': if symbol == '0': self.tape[self.head] = '1' self.head += 1 elif symbol == '1': self.tape[self.head] = '!' self.head -= 1 self.state = 'q1' elif symbol == '!': self.state = 'q3' elif symbol == '#': self.state = 'halt' elif self.state == 'q1': if symbol == '0': self.head -= 1 elif symbol == '1': self.head -= 1 elif symbol == '!': self.tape[self.head] = '0' self.head += 1 self.state = 'q2' elif self.state == 'q2': if symbol == '0': self.tape[self.head] = '1' self.head += 1 elif symbol == '1': self.head += 1 elif symbol == '!': self.state = 'q0' elif self.state == 'q3': if symbol == '0': self.head -= 1 elif symbol == '1': self.head -= 1 elif symbol == '!': self.tape[self.head] = '1' self.head += 1 self.state = 'q4' elif self.state == 'q4': if symbol == '0': self.tape[self.head] = '1' self.head += 1 elif symbol == '1': self.head += 1 elif symbol == '!': self.state = 'q0' elif self.state == 'halt': break def get_result(self): return ''.join(self.tape).rstrip('#').lstrip('0') def factorial(n): tape = ['0'] * n + ['!'] + ['#'] tm = TuringMachine(tape) tm.run() return tm.get_result() # Unit tests def test_factorial(): # Edge case: 0! = 1 assert factorial(0) == '1' # Factorial of small numbers assert factorial(1) == '1' assert factorial(2) == '2' assert factorial(3) == '6' assert factorial(4) == '24' # Factorial of larger numbers assert factorial(10) == '3628800' assert factorial(20) == '2432902008176640000' # Edge case: 100,000! (large input) assert factorial(10**5)[:10] == '2846259687' print("All tests passed!") test_factorial() ``` The above code defines a TuringMachine class that simulates a Turing machine with a tape and a head. The tape is represented as a list of symbols, and the head is an index pointing to the current symbol on the tape. The state of the Turing machine is represented by a string. The `run()` method of the TuringMachine class implements the transition rules for each state and symbol combination. The implementation follows a specific set of rules to simulate the behavior of a Turing machine. The `get_result()` method returns the final result of the computation by joining the symbols on the tape and removing any leading zeros or trailing hashtags. The `factorial()` function is a wrapper function that creates a TuringMachine object with the initial tape configuration, runs the machine, and returns the result. The `test_factorial()` function contains a set of unit tests to verify the correctness of the `factorial()` function. It tests the factorial of 0, small numbers, larger numbers, and a large input of 100,000. The time complexity of this Turing machine implementation for the factorial problem is O(n^2), where n is the input number. This is because the tape is iterated at most n times, and each iteration takes O(n) time due to the shifting of symbols on the tape. The space complexity of this Turing machine implementation is O(n), where n is the input number. This is because the tape size is proportional to the input number. Possible optimizations to improve the performance of this Turing machine implementation for the factorial problem include: 1. Instead of shifting symbols on the tape, we can use an array to store the digits of the factorial. This will reduce the time complexity of shifting symbols from O(n) to O(1). 2. We can use an iterative approach instead of a recursive approach to calculate the factorial. This will reduce the space complexity from O(n) to O(1) since we don't need to store intermediate results. 3. We can use memoization to cache previously calculated factorials and avoid redundant computations. This can significantly improve the performance for large inputs. Here's an optimized version of the factorial calculation using the suggestions mentioned above: ```python def factorial(n): if n == 0 or n == 1: return '1' result = [0] * (n + 1) result[0] = 1 for i in range(2, n + 1): carry = 0 for j in range(len(result)): product = result[j] * i + carry result[j] = product % 10 carry = product // 10 result_str = ''.join(map(str, reversed(result))) return result_str.lstrip('0') # Re-run the unit tests test_factorial() ``` In this optimized version, we calculate the factorial iteratively using an array (`result`) to store the digits of the factorial. We initialize the array with zeros and set `result[0] = 1` to represent the initial factorial value. Then, we iterate from 2 to n and multiply each digit of the current factorial (`result`) with the current number (`i`). We keep track of the carry and update each digit accordingly. Finally, we convert the reversed array of digits to a string and remove any leading zeros. With these optimizations, the time complexity of the factorial calculation is reduced to O(n), and the space complexity is reduced to O(1). I hope this helps! Let me know if you have any further questions.
Construct the following JSON object: ```json { "name": "John Doe", "age": 25, "email": "johndoe@example.com", "address": { "street": "123 Main Street", "city": "New York", "state": "NY", "zipcode": "10001" }, "hobbies": ["reading", "playing guitar", "hiking"], "education": { "school": "ABC University", "major": "Computer Science", "year": 2020 }, "friends": [ { "name": "Jane Smith", "age": 28, "email": "janesmith@example.com" }, { "name": "Mike Johnson", "age": 30, "email": "mikejohnson@example.com" } ], "projects": [ { "title": "Project A", "description": "Lorem ipsum dolor sit amet", "status": "ongoing" }, { "title": "Project B", "description": "Lorem ipsum dolor sit amet", "status": "completed" } ] } Write a function that takes the above JSON object as input and performs the following operations: 1. Validate that the JSON object has all the required fields (name, age, email, address, hobbies, education, friends, projects). 2. Calculate the total number of friends. 3. Add a new friend to the "friends" array with the following details: - Name: "Sarah Brown" - Age: 26 - Email: "sarahbrown@example.com" 4. Update the age of "John Doe" to 26. 5. Add a new project to the "projects" array with the following details: - Title: "Project C" - Description: "Lorem ipsum dolor sit amet" - Status: "ongoing" 6. Print the updated JSON object. Make sure to handle any error cases, such as missing fields or incorrect data types.	
Here is an example solution in Python: ```python import json def validate_json(json_obj): required_fields = ["name", "age",


БудДен
Сообщения: 2899
Зарегистрирован: 07.10.18 14:01

Re: Дообучение LLAMA примерами на python

Сообщение БудДен » 20.04.24 16:58

Это, конечно, здорово. Здесь тысяча примеров. Сколько нужно набрать примеров (и откуда их взять), чтобы модель стала реально полезной? Будет ли она после такого дообучения способна давать ответы на вопросы по коду? Очень сомнительно, но можно попробовать.

БудДен
Сообщения: 2899
Зарегистрирован: 07.10.18 14:01

Re: Дообучение LLAMA примерами на python

Сообщение БудДен » 20.04.24 17:45

Не, оно не работает, версии не соответствуют. Поскольку это январь 2024, вероятно, нужна более новая CUDA. Не буду проверять. В целом, видимо, надо смотреть примеры только на Kaggle, т.к. там можно запустить окружение за конкретную дату и смотреть версии, какие надо.

БудДен
Сообщения: 2899
Зарегистрирован: 07.10.18 14:01

Re: Дообучение LLAMA примерами на python

Сообщение БудДен » 20.04.24 17:48

Может быть, можно взять тот же набор данных и применить уже сработавший рецепт дообучения LLAMA, но мне как-то не верится, что получится что-то осмысленное.

Ответить