ํ์ฌ ๋๊ธฐ์ ์ค์ฌ์ผ๋ก ์๋์ ๊ฐ์ ํ๋ก์ ํธ์ ๊ฐ๋ฐ์ฑ ์ ๋ฐ ์ปจ์คํ ์ ๋งก๊ณ ์์ต๋๋ค. ํ์ญ^^์ ๋๋ค.
๋๋ถ์ด, ๊ณ ๋ ค๋ ๋ํ์์์ ์ธ๊ณต์ง๋ฅ ๊ด๋ จ ๊ฒธ์๊ต์๋ก๋ ํ๋ํ๊ณ ์์ต๋๋ค.
์ ์ ๋ชฉํ๋ ์ค์ ์ ๋ฐ๋ก ์จ๋จน์ ์ ์๋ ํ์ฅ๊ฐ ์๋ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ ์ ๋๋ค. ์์ผ๋ก ๋ง์ ์ฌ๋ฌ๋ถ๊ณผ ํจ๊ป ์ฌ๋ฏธ๋ ์์ ๋ง๋ค์ด ๋๊ฐ๊ณ ์ถ์ต๋๋ค.
์ํฐํ๋ผ์ด์ฆ ์ธ๊ณต์ง๋ฅ ๊ตฌ์กฐ ๋ฐ ์๋น์ค ์ค๊ณ
๋จธ์ ๋ฌ๋ ์๋น์ค ๊ตฌํ
๋ฒก์๋ ์๋น์ค ๊ฐ๋ฐ
ํด๋ผ์ฐ๋(Azure) Databricks, ETL, Fabric ๋ฑ ๊ฐ์ข ํด๋ผ์ฐ๋ ํ๊ฒฝ์์์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ตฌ์ถ ๋ฐ ์๋น์ค ๊ฐ๋ฐ
Courses
Reviews
devshin91
ยท
All-in-one masterclass from development to deployment for computer vision anomaly detectionAll-in-one masterclass from development to deployment for computer vision anomaly detectionmain33730814
ยท
All-in-one masterclass from development to deployment for computer vision anomaly detectionAll-in-one masterclass from development to deployment for computer vision anomaly detectioneverythx
ยท
All-in-one masterclass from development to deployment for computer vision anomaly detectionAll-in-one masterclass from development to deployment for computer vision anomaly detection- All-in-one masterclass from development to deployment for computer vision anomaly detection
cjnyung5173
ยท
All-in-one masterclass from development to deployment for computer vision anomaly detectionAll-in-one masterclass from development to deployment for computer vision anomaly detection
Posts
Q&A
end point ์์ฑ ๊ด๋ จ ์ง๋ฌธ๋๋ฆฝ๋๋ค!
"ํจ์น ์ ๋ฐ์ดํธ ๊ฐ์" ์น์ ์ ์ถ๊ฐํด์ ํด๋น ์ง๋ฌธ์ ๋ํ ๋์ฒ๋ฐฉ๋ฒ์ ์ฌ๋ ค๋์์ต๋๋ค.์์ ๋ต๋ณ์ด ๋ถ์กฑํ๋ฉด ์์์ ์ฐธ๊ณ ํ์๊ธฐ ๋ฐ๋๋๋ค. ๊ทธ๋ผ ์ด๊ณตํ์ธ์~
- 0
- 4
- 48
Q&A
์ฒดํ ๊ณ์ ์์๋ End-point ์์ฑ์ด ์ ๋๋๊ฑธ๊น์?
"ํจ์น ์ ๋ฐ์ดํธ ๊ฐ์" ์น์ ์ ์ถ๊ฐํด์ ํด๋น ์ง๋ฌธ์ ๋ํ ๋์ฒ๋ฐฉ๋ฒ์ ์ฌ๋ ค๋์์ต๋๋ค.์์ ๋ต๋ณ์ด ๋ถ์กฑํ๋ฉด ์์์ ์ฐธ๊ณ ํ์๊ธฐ ๋ฐ๋๋๋ค. ๊ทธ๋ผ ์ด๊ณตํ์ธ์~
- 0
- 2
- 49
Q&A
end point ์์ฑ ๊ด๋ จ ์ง๋ฌธ๋๋ฆฝ๋๋ค!
์์ธ์ ํ์ ํ์ต๋๋ค.Databricks ์ธก์์ ๊ธฐ์กด์ legacy serving ์ ์์ ๊ณ ์๋กญ๊ฒ Mosaic AI Model Serving ์ผ๋ก ์ ์ฑ ์ ๋ฐ๊พธ๋ฉด์, ์ฌ์ฉ์์ ML/DL ๋ชจ๋ธ์ ๋ฌผ๋ก , LLM ๋ชจ๋ธ๋ค์ ํ ๊ณณ์์ ๋ชจ๋ Serverless Model Serving ์ ํ๋๋ก ํด ๋์๋ค์.์ฐพ์๋ณด๋, ๊ธฐ์กด์ serving ์ผ๋ก ์ฌ๋ ค๋์ ๋ชจ๋ธ๋ค์ด run_id ๊ฐ ๊ทธ๋๋ก ์ด์ ์์์๋ ๋ถ๊ตฌํ๊ณ endpoint ๋ฅผ ์ข ์ ์ฒ๋ผ ์ด์ฉํ ์ ์๊ฒ ๋ฐ๊พธ์ด ๋์์ต๋๋ค. ์์ฌ์ด ์ ์ Mosaic AI Model Serving ์ด ์ ๋ฃ๋ผ๋ ์ ์ด๋ค์.https://www.databricks.com/product/pricing/model-serving ๊ทธ๋ ๊ธฐ์ ์ ๋ฃ ๊ณ์ ์ผ๋ก ์ฌ์ฉํ๊ณ ์์ผ๋ create endpoint ๊ฐ ๋์ํ์ง ์์ ๊ฑฐ์์. pricing ์ ํ์ธํด ๋ณด๋ฉด ๋น์ฉ์ ๋งค์ฐ ์ ๋ ดํ ํธ์ด๋ผ ํ์ต์ฉ์ผ๋ก ์ฝ๊ฐ ์ด์ฉํ๋ ์์ค์ด๋ผ๋ฉด ๋ถ๋ด์ ์์ ๊ฒ์ผ๋ก ๋ณด์ฌ์. serverless serving ์ด ํน์ง์ด๋ค๋ณด๋, create endpoint ๋ฅผ ๋๋ฅด๋ฉด container ๋ ์ง์คํธ๋ฆฌ๊ฐ ์์ฑ๋๋ฉฐ REST API๋ก ์๋ํฌ์ธํธ๊ฐ ์ ๊ณต๋์ด, ์ข ์ ๋ณด๋ค ํจ์ฌ ํธํ๊ฒ ๋ชจ๋ธ์ ์ด์ฉํ ์ ์๋ค๋ ์ ์ด ๊ฐ์ฅ ํฐ ์ฅ์ ์ ๋๋ค.
- 0
- 4
- 48
Q&A
end point ์์ฑ ๊ด๋ จ ์ง๋ฌธ๋๋ฆฝ๋๋ค!
๋ฐ์ดํฐ๋ธ๋ฆญ์ค๊ฐ ์ ๋ฐ์ดํธ๋๋ฉด์ ๋ฐ์ํ๋ ํ์์ธ๊ฒ ๊ฐ์๋ฐ์, ํ์ธํด๋ณด๊ณ ์ฐ๋ฝ๋๋ฆฌ๋๋ก ํ ๊ฒ์~
- 0
- 4
- 48
Q&A
์ด๋ฏธ์ง ๋ ธ์ด์ฆ ์ถ๊ฐํ๋ ์ฝ๋ ๊ณต์ ๋ถํ๋๋ฆฝ๋๋ค.
์๋ ํ์ธ์~๋ง์ด ๋ต๋ตํ์ จ๊ฒ ๋ค์.ํ์ํ์ ์ฝ๋๋ฅผ ๊ณต์ ํฉ๋๋ค~import numpy as np import matplotlib.pyplot as plt from PIL import Image, ImageDraw from pathlib import Path def load_image(file_path: Path) -> np.array: """ Load an image from a given file path and convert it to a NumPy array. Args: file_path (Path): Path to the image file. Returns: np.array: The image as a NumPy array. """ pil_image = Image.open(file_path) return np.array(pil_image) def add_irregular_patch(noisy_image: np.array, patch_pixels: int, noise_value: int) -> np.array: """ Adds an irregular, polygonal noise patch to the image. Args: noisy_image (np.array): The image array to modify. patch_pixels (int): Approximate area of the noise patch in pixels. noise_value (int): Noise value (255 for salt, 0 for pepper). Returns: np.array: The modified image with the noise patch added. """ img_pil = Image.fromarray(noisy_image) draw = ImageDraw.Draw(img_pil) img_width, img_height = img_pil.size # Estimate an average radius from the patch area (area โ ฯrยฒ) r = int(np.sqrt(patch_pixels / np.pi)) r = max(r, 5) # Ensure a minimum patch size # Choose a random center where the patch can fit center_x = np.random.randint(r, img_width - r) center_y = np.random.randint(r, img_height - r) # Random number of vertices for the irregular polygon num_points = np.random.randint(5, 10) angles = np.linspace(0, 2 * np.pi, num_points, endpoint=False) angles += np.random.uniform(0, 2 * np.pi / num_points, size=num_points) # Generate random radii for each vertex around the average radius radii = np.random.uniform(0.5 * r, 1.5 * r, size=num_points) # Create the polygon points points = [ (int(center_x + radius * np.cos(angle)), int(center_y + radius * np.sin(angle))) for angle, radius in zip(angles, radii) ] # Set the fill color based on image mode fill_color = (noise_value, noise_value, noise_value) if img_pil.mode == 'RGB' else noise_value draw.polygon(points, fill=fill_color) return np.array(img_pil) def random_patch_areas(total: int, num_patches: int) -> np.array: """ Split the total noise area into a random distribution of patch areas that sum to total. Args: total (int): Total number of noisy pixels for this noise type. num_patches (int): Number of patches. Returns: np.array: Array of patch areas. """ areas = np.random.rand(num_patches) areas = areas / areas.sum() # Normalize so areas sum to 1 areas = (total * areas).astype(int) # Adjust in case of rounding issues diff = total - areas.sum() areas[0] += diff return areas def apply_random_irregular_noise(image: np.array, amount: float, salt_vs_pepper: float) -> np.array: """ Applies random irregular noise patches (both salt and pepper) to an image. Args: image (np.array): The original image. amount (float): Fraction of total image pixels to be noised. salt_vs_pepper (float): Fraction of noise that is salt (white). Returns: np.array: The noisy image. """ noisy = image.copy() total_pixels = image.shape[0] * image.shape[1] num_pixels = int(amount * total_pixels) # Calculate noise areas for salt and pepper num_salt = int(salt_vs_pepper * num_pixels) num_pepper = num_pixels - num_salt # Randomly determine number of patches (e.g., 1 to 3 patches) num_salt_patches = np.random.randint(1, 10) num_pepper_patches = np.random.randint(1, 10) # Split the noise area into patch areas salt_patch_areas = random_patch_areas(num_salt, num_salt_patches) pepper_patch_areas = random_patch_areas(num_pepper, num_pepper_patches) # Add salt noise patches for area in salt_patch_areas: noisy = add_irregular_patch(noisy, area, 255) # Add pepper noise patches for area in pepper_patch_areas: noisy = add_irregular_patch(noisy, area, 0) return noisy def plot_images(original: np.array, noisy: np.array) -> None: """ Plots the original and noisy images side by side. Args: original (np.array): The original image. noisy (np.array): The noisy image. """ fig, axes = plt.subplots(1, 2, figsize=(10, 5)) axes[0].imshow(original) axes[0].set_title("Original Image") axes[0].axis("off") axes[1].imshow(noisy) axes[1].set_title("Image with Random Irregular Noise Patches") axes[1].axis("off") plt.tight_layout() plt.show() def main(file_path:Path, amount:float, salt_vs_pepper:float): # Load the image image = load_image(file_path) # Apply the noise noisy_image = apply_random_irregular_noise(image, amount, salt_vs_pepper) pil_image = Image.fromarray(noisy_image) # save noisy image output_file_path = Path('noisy_frames') / f"{file_path.stem}_noisy{file_path.suffix}" output_file_path.parent.mkdir(exist_ok=True) pil_image.save(output_file_path, format='JPEG') # Display the original and noisy images plot_images(image, noisy_image) if __name__ == "__main__": file_path = Path('frames') / 'frame_0.jpg' amount = 0.01 # Fraction of image pixels to be noised salt_vs_pepper = 0.6 # Fraction of noise that is salt (white) main(file_path, amount, salt_vs_pepper)
- 1
- 3
- 32
Q&A
df ์์ ๋ฐ์ด๋๋ฆฌ ๊ฐ ์ด๋ฏธ์ง๋ก ์๋ณด์ด๋ ํ์
์๋ ํ์ธ์, ์ด๊ณต ํ์๋ ๋ชจ์ต ๋๋ฌด ๋ณด๊ธฐ ์ข์ต๋๋ค~^^ ์ผ๋จ, metadata ์ ์ฉ์๋ ๋ฌธ์ ๊ฐ ์์ต๋๋ค. spark 3.3+ ์ด๋ฉด ๋ฉํ๋ฐ์ดํฐ๋ฅผ ํตํด display() ๋ฅผ ํตํด df ์ ์ด๋ฏธ์ง๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ์ ์ ์์ ์ผ๋ก ์ด๋ฃจ์ด์ ธ์ผ ํฉ๋๋ค. ์ผ๋จ, ๋ ๊ฐ์ง๋ฅผ ์์ฌํด ๋ณผ ์ ์๊ฒ ๋ค์. 1. path.replace("dbfs:", "") ๋ถ๋ถ์ด ๋ฌธ์ ๊ฐ ์์ด ๋ณด์ด๋ค์. /dbfs ๊ฐ ๋ฐ์ดํฐ๋ธ๋ฆญ์ค ๋ณผ๋ฅจ์ ๊ธฐ๋ณธ ๋จ์์ผํ ๋ฐ, ์ด๊ฒ์ ์ญ์ ํ ๊ฒ์ด ๋ฌธ์ ๊ฐ ๋๋ ์ง ์ฒดํฌํด ๋ณด์ธ์. from PIL import Image ํธ์ถ์ด ์๋์ด ์๋๋ฐ, ์ด ๋ถ๋ถ๋ ์ฒดํฌ ํ ๋ฒ ํด ๋ณด์๊ตฌ์.์ด๋ ๊ฒ ํด์๋ ํด๊ฒฐ์ด ์๋๋ค๋ฉด,pandas_udf ๋ก ๋ง๋ค๊ธฐ ์ ์ ์ํ ๊ฒฝ๋ก ํ๋๋ฅผ ๊ฐ์ง๊ณ ์ ์์ ์ผ๋ก ์๋ํ๋ ์ง ํ์ธ ํ์ ์ต์ข ์ ์ผ๋ก ์ฌ์ฉํ๋ฉด udf๋ก ๋ง๋ค์ด ์ฌ์ฉํ๋ค๋ฉด ์๋ง ์ค๋ฅ๋ฅผ ์ก์๋ผ ์ ์์ง ์์๊น ์๊ฐํฉ๋๋ค. ๊ทธ๋ผ ์ด๊ณตํ์ธ์!
- 0
- 1
- 26
Q&A
์ฝ๋ ์๋ฃ ์์ฒญ
๋ค, ์ด๋ฉ์ผ ๋ณด๋์ต๋๋ค. ํ์ธํด ๋ณด์ธ์.์ด๊ณต!
- 0
- 2
- 35
Q&A
o3-mini ๋ชจ๋ธ์ ์ด๋ฏธ์ง๋ฅผ ์ง์์ํ๋์
์๋ ํ์ธ์! o3-mini ๋ ๋น์ ๊ธฐ๋ฅ์ ์ง์ํ์ง ์๋ ๊ฒ์ผ๋ก ์๊ณ ์์ต๋๋ค. STEM ์ค์ฌ์ ์๋๋ฆฌ์ค์ ์ ํฉํ๋ ๋ชจ๋ธ์ด๋ผ๊ณ ์๊ฐํ์๋ฉด ๋ ๊ฒ ๊ฐ์์. ์ฝ๋๋ฅผ ๋ฐ๋ผํ๋ฉด์ ์๋ง ๋ค์ํ ๋ชจ๋ธ์ ํ ์คํธ ํด ๋ณด์๋ ๊ฒ ๊ฐ์๋ฐ์, ๊ฐ๋ ์ด๋ ๊ฒ ์ค๋ฅ๊ฐ ๋๋ฉด ๋นํฉ์ค๋ฌ์ธ ์ ์์ต๋๋ค. ๊ทธ๋ด ๋, ๋ชจ๋ธ์ด ์ง์ํ๋ ๊ธฐ๋ฅ์ ํ๊ณ ๋ฑ์ ์๋ฃ๋ฅผ ์ฐพ์๋ณด๋ฉด ๋์์ด ๋ฉ๋๋ค^^ ๊ทธ๋ผ ์ด๊ณตํ์ธ์~
- 0
- 1
- 25
Q&A
ํตํฉ ํ๋ ์์ํฌ ๊ฐ์ ์์ฒญ๋๋ฆฝ๋๋ค
์๋ ํ์ธ์,๊ฐ์๊ฐ ๋์์ด ๋์๋ค๋ ๊ธฐ์ฉ๋๋ค. MLOps ์ ๋ํ์ฌ ๊ด์ฌ์ด ๋ง์ผ์๊ตฐ์. ์์ฑํ AI ์๋์ ๊ฐ๊ณผํ๊ธฐ ์ฌ์ด ML์ ์ค์์ฑ์ ์ ์๊ณ ์์ผ์ ์, ๋ฐ์ด๋ ๊ฐ๋ฐ์๊ฐ ๋ ๊ฒ์ด๋ผ ๋ฏฟ์ต๋๋ค. ์๊ทธ๋๋ ์ธํ๋ฐ ์ธก์์ MLOps ๊ฐ์์ ๋ํ ์์ฒญ์ ๊พธ์คํ ํด ์์ ์ด๋ค ์ฃผ์ ๋ฅผ ๋ค๋ฃฐ๊น ๊ตฌ์์ค์ด์๋๋ฐ์. ํ์ฌ ์์ ์ค์ธ RAG All Master ๊ฐ์๊ฐ ์๋ฃ๋๋๋๋ก MLOps ๊ฐ์๋ฅผ ์ค๋นํด ๋ด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋๋ค์. ํน์ ๋ณธ์ธ์ ๋ฌผ๋ก ํ์ต์์ ์ ์ฅ์์ ์๊ฐํ๊ณ ์๋ ์ข ๋ ๊ตฌ์ฒด์ ์ธ end-to-end MLOps ๊ฐ์์ ๋ํ ์๊ฒฌ์ ์ฃผ์๋ฉด ๊ณ ๋ง๊ฒ ์ต๋๋ค.ํนํ, '์ค์ ๋ก ์ฌ์ฉํ๋ ๋ชจ์ต', 'ํํธ๋น ์ฐ๊ฒฐ๋๋ ๋ถ๋ถ', '์ต์ข ์ ์ผ๋ก ๋ฐฐ์ด ๊ฒ๋ค์ ์ตํฉ' ์ด๋ ํค์๋์์ ๋๋ ์ ์, ํ์ต์ฉ ๊ด์ ์ด ์๋ '์จ์ ํ ๊ธฐ๋ฅํ๋ MLOps' ์ค์ ํ๋ก์ ํธ ๋๋ ์ค์ ํ๋ก์ ํธ์ ๋์ผํ ์ค์ผ์ผ์ ๋ด์ฉ์ด ๋ด๊ฒจ์ก์ผ๋ฉด ํ๋ ๊ฒ์ผ๋ก ์ฝํ๋๋ค.^^ ํผ๋๋ฐฑ ์ฃผ์๋ฉด ๊ณ ๋ง๊ฒ ์ต๋๋ค~
- 1
- 2
- 38
Q&A
32๊ฐ ๊ฐ์๊ฐ ์งค๋ฆฐ๊ฑฐ ๊ฐ์ต๋๋ค.
์๋ ํ์ธ์, ๋ถํธํจ์ ๋๋ ค ์ฃ์กํ๋ค์. ์ ๋ ๋ฌด์ฒ ๋นํฉํ๋๋ฐ์, ๊ฐ์๊ฐ ์๋ฆฐ ๊ฒ์ด ์๋๋ผ, ์ธํ๋ฐ ์๋ฒ ์ชฝ์ ๋ฌธ์ ์ธ ๊ฒ ๊ฐ์ต๋๋ค. ๊ฐ์ ์์์ ์ ์์ ์ผ๋ก ์ ๋ก๋ ๋์๊ณ , ์ง๊ธ๊น์ง ์ด์ ๊ฐ์ ๋ฌธ์ ๋ ์์๊ฑฐ๋ ์.ํน์๋, ํด์ ๋ค์ ๋ค์ด๊ฐ ๋ด๋ ์์์๋ ๋ฌธ์ ๊ฐ ์๋ ๊ฒ์ ํ์ธํ์์ต๋๋ค. ๊ณ ๊ฐ์ผํฐ๋ก ๋ฌธ์๋ฅผ ํด ์ฃผ์ ์ผ ํ ๊ฒ ๊ฐ์์. ๋ง์ผ ์ผ์์ ์ธ ์ธํ๋ฐ ์๋ฒ ์ฅ์ ์๋ค๋ฉด, ์๋ง ์ ๊ฐ ๋ต๋ณ์ ์์ฑํ๊ณ ์๋ ์ง๊ธ์ฏค ๋ฌธ์ ๊ฐ ํด๊ฒฐ๋์ง ์์์๊น ์ถ์ต๋๋ค. ๊ทธ๋ผ ์ด๊ณตํ์๊ตฌ์~๊ฐ์ฌํฉ๋๋ค.
- 0
- 2
- 26




